@tinyclaw/plugin-provider-openai 1.0.1-dev.3004a38

package/README.md

@@ -0,0 +1,19 @@
+# @tinyclaw/plugin-provider-openai
+
+OpenAI provider plugin for Tiny Claw. Adds OpenAI as an LLM provider, enabling the agent to use GPT models.
+
+## Setup
+
+1. Obtain an API key from <https://platform.openai.com/api-keys>
+2. Ask the agent to pair the OpenAI provider
+3. Provide the API key when prompted
+
+## How It Works
+
+- Registers an OpenAI-compatible provider with the agent
+- API key is stored securely via the secrets engine
+- Supports model selection through the agent's model management tools
+
+## License
+
+GPLv3

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @tinyclaw/plugin-provider-openai
+ *
+ * OpenAI provider plugin for Tiny Claw. Adds GPT-4.1, GPT-4o, and other
+ * OpenAI models as a provider option. Routes via the smart provider
+ * routing system based on query complexity tiers.
+ *
+ * Pairing flow:
+ *   1. Plugin is added to `plugins.enabled` (manually or via set_config)
+ *   2. On next boot, pairing tools (`openai_pair`, `openai_unpair`) appear
+ *   3. User provides API key via `openai_pair` → stored securely, tier mapping updated
+ *   4. Agent calls `tinyclaw_restart` → supervisor respawns with new configuration
+ */
+import type { ProviderPlugin } from '@tinyclaw/types';
+declare const openaiPlugin: ProviderPlugin;
+export default openaiPlugin;

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * @tinyclaw/plugin-provider-openai
+ *
+ * OpenAI provider plugin for Tiny Claw. Adds GPT-4.1, GPT-4o, and other
+ * OpenAI models as a provider option. Routes via the smart provider
+ * routing system based on query complexity tiers.
+ *
+ * Pairing flow:
+ *   1. Plugin is added to `plugins.enabled` (manually or via set_config)
+ *   2. On next boot, pairing tools (`openai_pair`, `openai_unpair`) appear
+ *   3. User provides API key via `openai_pair` → stored securely, tier mapping updated
+ *   4. Agent calls `tinyclaw_restart` → supervisor respawns with new configuration
+ */
+import { createOpenAIProvider } from './provider.js';
+import { createOpenAIPairingTools } from './pairing.js';
+const openaiPlugin = {
+    id: '@tinyclaw/plugin-provider-openai',
+    name: 'OpenAI',
+    description: 'OpenAI GPT models (GPT-4.1, GPT-4o, etc.)',
+    type: 'provider',
+    version: '0.1.0',
+    async createProvider(secrets) {
+        return createOpenAIProvider({ secrets });
+    },
+    getPairingTools(secrets, configManager) {
+        return createOpenAIPairingTools(secrets, configManager);
+    },
+};
+export default openaiPlugin;

package/dist/pairing.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OpenAI Pairing Tools
+ *
+ * Two tools that implement the OpenAI provider pairing flow:
+ *
+ * 1. openai_pair — Store the API key, configure model, enable plugin, update tier mapping
+ * 2. openai_unpair — Disable plugin and reset tier mapping
+ *
+ * These tools are injected into the agent's tool list at boot so the agent
+ * can invoke them conversationally when a user asks to connect OpenAI.
+ */
+import type { Tool, SecretsManagerInterface, ConfigManagerInterface } from '@tinyclaw/types';
+/** Secret key for the OpenAI API key. */
+export declare const OPENAI_SECRET_KEY = "provider.openai.apiKey";
+/** Config key for the model setting. */
+export declare const OPENAI_MODEL_CONFIG_KEY = "providers.openai.model";
+/** The plugin's package ID. */
+export declare const OPENAI_PLUGIN_ID = "@tinyclaw/plugin-provider-openai";
+/** The provider ID used in tier mapping. */
+export declare const OPENAI_PROVIDER_ID = "openai";
+/** Default model. */
+export declare const OPENAI_DEFAULT_MODEL = "gpt-4.1";
+export declare function createOpenAIPairingTools(secrets: SecretsManagerInterface, configManager: ConfigManagerInterface): Tool[];

package/dist/pairing.js

@@ -0,0 +1,110 @@
+/**
+ * OpenAI Pairing Tools
+ *
+ * Two tools that implement the OpenAI provider pairing flow:
+ *
+ * 1. openai_pair — Store the API key, configure model, enable plugin, update tier mapping
+ * 2. openai_unpair — Disable plugin and reset tier mapping
+ *
+ * These tools are injected into the agent's tool list at boot so the agent
+ * can invoke them conversationally when a user asks to connect OpenAI.
+ */
+/** Secret key for the OpenAI API key. */
+export const OPENAI_SECRET_KEY = 'provider.openai.apiKey';
+/** Config key for the model setting. */
+export const OPENAI_MODEL_CONFIG_KEY = 'providers.openai.model';
+/** The plugin's package ID. */
+export const OPENAI_PLUGIN_ID = '@tinyclaw/plugin-provider-openai';
+/** The provider ID used in tier mapping. */
+export const OPENAI_PROVIDER_ID = 'openai';
+/** Default model. */
+export const OPENAI_DEFAULT_MODEL = 'gpt-4.1';
+export function createOpenAIPairingTools(secrets, configManager) {
+    return [
+        {
+            name: 'openai_pair',
+            description: 'Pair Tiny Claw with OpenAI as a provider. ' +
+                'Stores the API key securely, configures the model, enables the plugin, ' +
+                'and routes complex/reasoning queries to OpenAI. ' +
+                'After pairing, call tinyclaw_restart to apply the changes. ' +
+                'To get an API key: go to https://platform.openai.com/api-keys and create one.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    apiKey: {
+                        type: 'string',
+                        description: 'OpenAI API key (starts with sk-)',
+                    },
+                    model: {
+                        type: 'string',
+                        description: 'OpenAI model to use (default: gpt-4.1). ' +
+                            'Examples: gpt-4.1, gpt-4o, gpt-4.1-mini',
+                    },
+                },
+                required: ['apiKey'],
+            },
+            async execute(args) {
+                const apiKey = args.apiKey;
+                if (!apiKey || apiKey.trim() === '') {
+                    return 'Error: apiKey must be a non-empty string.';
+                }
+                const model = args.model?.trim() || OPENAI_DEFAULT_MODEL;
+                try {
+                    // 1. Store API key in secrets engine
+                    await secrets.store(OPENAI_SECRET_KEY, apiKey.trim());
+                    // 2. Set model in config
+                    configManager.set(OPENAI_MODEL_CONFIG_KEY, model);
+                    // 3. Add plugin to enabled list (deduplicated)
+                    const current = configManager.get('plugins.enabled') ?? [];
+                    if (!current.includes(OPENAI_PLUGIN_ID)) {
+                        configManager.set('plugins.enabled', [...current, OPENAI_PLUGIN_ID]);
+                    }
+                    // 4. Update tier mapping — route complex + reasoning to OpenAI
+                    configManager.set('routing.tierMapping.complex', OPENAI_PROVIDER_ID);
+                    configManager.set('routing.tierMapping.reasoning', OPENAI_PROVIDER_ID);
+                    return (`OpenAI provider paired successfully! ` +
+                        `Model: ${model}. API key stored securely. ` +
+                        `Complex and reasoning queries will be routed to OpenAI. ` +
+                        `Use the tinyclaw_restart tool now to apply the changes.`);
+                }
+                catch (err) {
+                    return `Error pairing OpenAI: ${err.message}`;
+                }
+            },
+        },
+        {
+            name: 'openai_unpair',
+            description: 'Disconnect OpenAI provider and disable the plugin. ' +
+                'Resets routing so all queries go back to the default provider. ' +
+                'The API key is kept in secrets for safety. Call tinyclaw_restart after.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+            async execute() {
+                try {
+                    // 1. Remove from plugins.enabled
+                    const current = configManager.get('plugins.enabled') ?? [];
+                    configManager.set('plugins.enabled', current.filter((id) => id !== OPENAI_PLUGIN_ID));
+                    // 2. Reset tier mapping entries that point to 'openai'
+                    const tiers = ['simple', 'moderate', 'complex', 'reasoning'];
+                    for (const tier of tiers) {
+                        const key = `routing.tierMapping.${tier}`;
+                        const val = configManager.get(key);
+                        if (val === OPENAI_PROVIDER_ID) {
+                            configManager.set(key, 'ollama-cloud');
+                        }
+                    }
+                    return ('OpenAI provider disabled. ' +
+                        'All queries will route to the default provider. ' +
+                        'Use the tinyclaw_restart tool now to apply the changes. ' +
+                        'The API key is still stored in secrets — use list_secrets to manage it.');
+                }
+                catch (err) {
+                    return `Error unpairing OpenAI: ${err.message}`;
+                }
+            },
+        },
+    ];
+}

package/dist/provider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * OpenAI Provider
+ *
+ * Creates a Provider that talks to the OpenAI Chat Completions API.
+ * Uses fetch directly — no external SDK dependency.
+ *
+ * Supports:
+ * - Configurable model (default: gpt-4.1)
+ * - Configurable base URL (for Azure / OpenAI-compatible endpoints)
+ * - Tool/function calling with automatic format conversion
+ * - API key resolution from secrets-engine
+ */
+import type { Provider, SecretsManagerInterface } from '@tinyclaw/types';
+export interface OpenAIProviderConfig {
+    secrets: SecretsManagerInterface;
+    /** Model to use (default: 'gpt-4.1'). */
+    model?: string;
+    /** Base URL for the API (default: 'https://api.openai.com'). */
+    baseUrl?: string;
+}
+export declare function createOpenAIProvider(config: OpenAIProviderConfig): Provider;

package/dist/provider.js

@@ -0,0 +1,132 @@
+/**
+ * OpenAI Provider
+ *
+ * Creates a Provider that talks to the OpenAI Chat Completions API.
+ * Uses fetch directly — no external SDK dependency.
+ *
+ * Supports:
+ * - Configurable model (default: gpt-4.1)
+ * - Configurable base URL (for Azure / OpenAI-compatible endpoints)
+ * - Tool/function calling with automatic format conversion
+ * - API key resolution from secrets-engine
+ */
+import { logger } from '@tinyclaw/logger';
+function toOpenAIMessages(messages) {
+    return messages.map((msg) => {
+        const out = {
+            role: msg.role,
+            content: msg.content ?? null,
+        };
+        // Assistant messages with tool calls
+        if (msg.role === 'assistant' && msg.toolCalls?.length) {
+            out.tool_calls = msg.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: {
+                    name: tc.name,
+                    arguments: JSON.stringify(tc.arguments),
+                },
+            }));
+        }
+        // Tool result messages
+        if (msg.role === 'tool' && msg.toolCallId) {
+            out.tool_call_id = msg.toolCallId;
+        }
+        return out;
+    });
+}
+function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+function parseToolCalls(raw) {
+    return raw.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: JSON.parse(tc.function.arguments),
+    }));
+}
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
+export function createOpenAIProvider(config) {
+    const baseUrl = config.baseUrl || 'https://api.openai.com';
+    const model = config.model || 'gpt-4.1';
+    return {
+        id: 'openai',
+        name: `OpenAI (${model})`,
+        async chat(messages, tools) {
+            try {
+                const apiKey = await config.secrets.resolveProviderKey('openai');
+                if (!apiKey) {
+                    throw new Error('No API key available for OpenAI. ' +
+                        'Store one with: store_secret key="provider.openai.apiKey" value="sk-..."');
+                }
+                const body = {
+                    model,
+                    messages: toOpenAIMessages(messages),
+                };
+                if (tools?.length) {
+                    body.tools = toOpenAITools(tools);
+                }
+                const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(body),
+                });
+                if (!response.ok) {
+                    const errorBody = await response.text();
+                    throw new Error(`OpenAI API error: ${response.status} ${response.statusText} — ${errorBody}`);
+                }
+                const data = await response.json();
+                logger.debug('OpenAI raw response:', JSON.stringify(data).slice(0, 500));
+                const choice = data.choices?.[0]?.message;
+                if (!choice) {
+                    throw new Error('OpenAI API returned no choices');
+                }
+                // Tool calls response
+                if (choice.tool_calls?.length) {
+                    return {
+                        type: 'tool_calls',
+                        content: choice.content ?? undefined,
+                        toolCalls: parseToolCalls(choice.tool_calls),
+                    };
+                }
+                // Text response
+                return {
+                    type: 'text',
+                    content: choice.content ?? '',
+                };
+            }
+            catch (error) {
+                logger.error('OpenAI provider error:', error);
+                throw error;
+            }
+        },
+        async isAvailable() {
+            try {
+                const apiKey = await config.secrets.resolveProviderKey('openai');
+                if (!apiKey)
+                    return false;
+                const response = await fetch(`${baseUrl}/v1/models`, {
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                    },
+                });
+                return response.ok;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@tinyclaw/plugin-provider-openai",
+  "version": "1.0.1-dev.3004a38",
+  "description": "OpenAI provider plugin for Tiny Claw",
+  "license": "GPL-3.0",
+  "author": "Waren Gonzaga",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/warengonzaga/tinyclaw.git",
+    "directory": "plugins/provider/plugin-provider-openai"
+  },
+  "homepage": "https://github.com/warengonzaga/tinyclaw/tree/main/plugins/provider/plugin-provider-openai#readme",
+  "bugs": {
+    "url": "https://github.com/warengonzaga/tinyclaw/issues"
+  },
+  "keywords": [
+    "tinyclaw",
+    "plugin",
+    "provider",
+    "openai"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@tinyclaw/logger": "workspace:*",
+    "@tinyclaw/types": "workspace:*"
+  }
+}