GPTScript

Parses .gpt files written in natural language into an executable program AST, resolving tool dependencies and program references through a modular loader system. The Program Loader (pkg/loader/loader.go) handles syntax parsing, dependency resolution, and tool binding without requiring explicit type definitions or schema declarations. Programs can reference external tools, built-in utilities, and other .gpt files as composable modules.

Manages interactions with multiple LLM providers (OpenAI, Anthropic, custom remote APIs) through a unified Registry system (pkg/llm/registry.go) that abstracts provider-specific APIs. The Engine coordinates with the Registry to select and invoke the appropriate LLM provider based on the requested model name, handling authentication, request formatting, and response parsing transparently. Supports both direct API calls and remote LLM endpoints.

Enables LLM programs to request user input interactively during execution through a prompting system that pauses execution, displays a prompt to the user, and captures their response. Prompts can be simple text input, multiple choice selections, or confirmation dialogs. The Engine integrates prompting into the execution loop, allowing LLMs to ask clarifying questions or request user decisions mid-workflow.

Enables developers to write reusable tool definitions and programs as .gpt files that can be composed into larger workflows, with support for tool parameters, return values, and documentation. Tools are authored in natural language with input/output specifications, and can be referenced by other programs or tools. The loader resolves tool references and builds a dependency graph, enabling modular program construction.

Provides real-time monitoring of program execution with structured logging (pkg/monitor/display.go) that captures LLM calls, tool invocations, and execution flow. Logs include timestamps, execution context, and detailed information about each step. Display system formats logs for terminal output with color coding and progress indicators, and supports structured output formats for programmatic consumption.

Enables LLMs to invoke external tools (CLI commands, HTTP endpoints, SDK functions) through a declarative tool registry that maps natural language tool descriptions to executable handlers. Tools are defined with input/output schemas and bound to execution handlers (cmd, http, or built-in functions) in pkg/engine/cmd.go and pkg/engine/http.go. The Engine automatically formats tool calls from LLM responses, validates inputs against schemas, and executes the appropriate handler.

Maintains conversation state across multiple LLM interactions within a single execution context, preserving tool outputs and LLM responses in a message history that feeds into subsequent LLM calls. The Engine (pkg/engine/engine.go) manages the conversation loop, appending each LLM response and tool result to the context, enabling the LLM to reason over previous steps and tool outputs. Context is passed to the LLM on each turn, allowing multi-step reasoning and error recovery.

Caches LLM completions and tool outputs to avoid redundant API calls and computation, using a completion cache system (pkg/gptscript/gptscript.go) that stores results keyed by request hash. When the same prompt, model, and tool context are encountered again, the cached result is returned instead of invoking the LLM or tool. Cache can be disabled per-execution or cleared explicitly via CLI flags.

Provides a standard library of built-in tools (pkg/builtin/builtin.go) for common operations like file I/O, HTTP requests, shell command execution, and text processing, available to all programs without explicit definition. Built-in tools are pre-registered in the tool registry and can be invoked by LLMs alongside user-defined tools. Tools include file read/write, directory listing, HTTP GET/POST, and shell execution with output capture.

Automatically generates tool definitions from OpenAPI specifications, allowing LLMs to invoke REST APIs by parsing OpenAPI schemas and creating corresponding tool handlers. The system converts OpenAPI endpoint definitions into tool schemas with input/output mappings, enabling LLMs to discover and call API endpoints without manual tool definition. HTTP handler (pkg/engine/http.go) executes the generated tool calls by mapping LLM parameters to HTTP requests.

Provides a command-line interface (pkg/cli/gptscript.go) for executing .gpt programs with flexible input/output handling, supporting stdin/stdout redirection, file input/output, and interactive prompts. The CLI parses command-line arguments, manages execution options (cache settings, API keys, model selection), and formats program output for terminal display or file writing. Supports both batch execution and interactive chat mode.

Exposes GPTScript execution capabilities through an HTTP API server (pkg/server/server.go) that allows programmatic invocation of programs and tool execution from external applications. The SDK server provides REST endpoints for running programs, listing tools, managing credentials, and streaming execution results. Enables integration with web applications, microservices, and other systems without requiring direct CLI invocation.

Manages API credentials and authentication tokens for LLM providers and external tools through a secure credential store (pkg/cli credential management) with support for environment variables, CLI flags, and interactive prompts. Credentials are stored securely (platform-specific secure storage) and automatically injected into tool execution contexts. Supports credential scoping per provider and tool.