GPTScript

Parses .gpt files written in natural language syntax into executable programs, using a custom loader (pkg/loader/loader.go) that resolves program dependencies, tool references, and nested scripts. The Engine component orchestrates execution by interpreting natural language instructions as LLM prompts and tool invocations, enabling developers to write multi-step workflows without explicit control flow syntax.

Implements a pluggable LLM provider system (pkg/llm/registry.go) that abstracts multiple LLM backends (OpenAI, Anthropic, custom remote APIs) behind a unified interface. The Registry component selects the appropriate provider based on requested model names, allowing programs to specify models declaratively without code changes. Supports both direct API integration (OpenAI client in pkg/openai/client.go) and remote provider delegation (pkg/remote/remote.go) for custom LLM services.

Exposes GPTScript functionality through an HTTP API server (pkg/server/server.go) that enables programmatic access from other applications. The SDK Server provides REST endpoints for program execution, chat sessions, model listing, and tool discovery. Supports both synchronous and asynchronous execution modes with webhook callbacks for long-running operations.

Provides introspection APIs (pkg/gptscript/gptscript.go ListModels, ListTools methods) that enumerate available LLM models and tools, enabling dynamic discovery of capabilities. The system queries LLM providers for available models and introspects tool definitions to expose their schemas and capabilities. Supports filtering and searching across available options.

Implements a monitoring system (pkg/monitor/display.go) that captures execution events, tool calls, and LLM interactions with structured logging and formatted display. The system tracks execution state, logs tool invocations with inputs/outputs, and provides real-time progress updates. Supports multiple output formats (text, JSON, structured logs) and configurable verbosity levels.

Enables LLMs to invoke external tools through a schema-based function registry that automatically binds tool definitions to LLM function-calling APIs. Tools are defined declaratively in .gpt files with input/output schemas, and the Engine translates these into provider-native function calling formats (OpenAI functions, Anthropic tools, etc.). Supports built-in tools (file I/O, HTTP, shell commands) and custom tools via OpenAPI integration.

Provides a set of pre-integrated system tools (pkg/builtin/builtin.go) that LLMs can invoke directly: shell command execution, file read/write operations, and HTTP requests. These tools are automatically available in all programs without explicit definition, with sandboxing and permission controls. The Engine handles tool invocation, output capture, and error handling transparently.

Automatically generates tool definitions from OpenAPI/Swagger specifications, enabling LLMs to discover and invoke API endpoints without manual tool definition. The system parses OpenAPI specs, extracts endpoint schemas, and creates callable tools with proper input validation and response handling. Supports both local spec files and remote spec URLs.

Implements a completion cache (pkg/gptscript/gptscript.go) that stores LLM responses and reuses them for identical inputs, reducing API costs and latency. The cache is keyed by prompt content, model, and parameters, with support for cache invalidation and manual clearing. Integrates with provider-native caching where available (e.g., OpenAI's prompt caching) and falls back to local caching.

Provides a chat interface (pkg/gptscript/gptscript.go Chat method) that maintains conversation history and context across multiple turns, enabling interactive LLM interactions within programs. The system manages message history, preserves tool execution context, and allows users to provide feedback or corrections. Supports both programmatic chat (via SDK) and CLI-based interactive mode.

Enables programs to reference and compose other .gpt programs as tools, with automatic dependency resolution and parameter passing. The Program Loader (pkg/loader/loader.go) parses program references, resolves nested dependencies, and validates parameter compatibility. Supports both local file references and remote program URLs, enabling modular workflow construction.

Manages API keys and credentials through environment variables and a credential store (pkg/cli/gptscript.go credential management), with support for secure storage and automatic injection into tool contexts. The system supports credential prompting (interactive input), environment variable loading, and credential caching. Credentials are scoped to specific tools and providers.

Provides a command-line interface (pkg/cli/gptscript.go) that executes .gpt programs with real-time output streaming, progress monitoring, and structured logging. The CLI handles argument parsing, input/output redirection, and display formatting. Supports both synchronous execution (blocking until completion) and asynchronous execution (returning immediately with status tracking).