kimaki 0.0.3 → 0.1.0

package/README.md

@@ -0,0 +1,7 @@
+creating a new bot
+
+- first tell user to go to https://discord.com/developers/applications and create a new app
+- get bot app id
+- get bot token in Discord clicking reset bot token. show a password input
+
+-

package/bin.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Restarts dist/cli.js if it exits non-zero.
+# Throttles restarts to at most once every 5 seconds.
+
+set -u -o pipefail
+
+NODE_BIN="${NODE_BIN:-node}"
+
+
+last_start=0
+
+while :; do
+  now=$(date +%s)
+  elapsed=$(( now - last_start ))
+  if (( elapsed < 5 )); then
+    sleep $(( 5 - elapsed ))
+  fi
+  last_start=$(date +%s)
+
+  "$NODE_BIN" "./dist/cli.js" "$@"
+  code=$?
+
+  # Exit cleanly if the app ended OK or via SIGINT/SIGTERM
+  if (( code == 0 || code == 130 || code == 143 || code == 64 )); then
+    exit "$code"
+  fi
+  # otherwise loop; the 5s throttle above will apply
+done

package/dist/ai-tool-to-genai.js

@@ -0,0 +1,207 @@
+import { Type } from '@google/genai';
+import { z, toJSONSchema } from 'zod';
+/**
+ * Convert JSON Schema to GenAI Schema format
+ * Based on the actual implementation used by the GenAI package:
+ * https://github.com/googleapis/js-genai/blob/027f09db662ce6b30f737b10b4d2efcb4282a9b6/src/_transformers.ts#L294
+ */
+function jsonSchemaToGenAISchema(jsonSchema) {
+    const schema = {};
+    // Map JSON Schema type to GenAI Type
+    if (jsonSchema.type) {
+        switch (jsonSchema.type) {
+            case 'string':
+                schema.type = Type.STRING;
+                break;
+            case 'number':
+                schema.type = Type.NUMBER;
+                schema.format = jsonSchema.format || 'float';
+                break;
+            case 'integer':
+                schema.type = Type.INTEGER;
+                schema.format = jsonSchema.format || 'int32';
+                break;
+            case 'boolean':
+                schema.type = Type.BOOLEAN;
+                break;
+            case 'array':
+                schema.type = Type.ARRAY;
+                if (jsonSchema.items) {
+                    schema.items = jsonSchemaToGenAISchema(jsonSchema.items);
+                }
+                if (jsonSchema.minItems !== undefined) {
+                    schema.minItems = jsonSchema.minItems;
+                }
+                if (jsonSchema.maxItems !== undefined) {
+                    schema.maxItems = jsonSchema.maxItems;
+                }
+                break;
+            case 'object':
+                schema.type = Type.OBJECT;
+                if (jsonSchema.properties) {
+                    schema.properties = {};
+                    for (const [key, value] of Object.entries(jsonSchema.properties)) {
+                        schema.properties[key] = jsonSchemaToGenAISchema(value);
+                    }
+                }
+                if (jsonSchema.required) {
+                    schema.required = jsonSchema.required;
+                }
+                // Note: GenAI Schema doesn't have additionalProperties field
+                // We skip it for now
+                break;
+            default:
+                // For unknown types, keep as-is
+                schema.type = jsonSchema.type;
+        }
+    }
+    // Copy over common properties
+    if (jsonSchema.description) {
+        schema.description = jsonSchema.description;
+    }
+    if (jsonSchema.enum) {
+        schema.enum = jsonSchema.enum.map(String);
+    }
+    if (jsonSchema.default !== undefined) {
+        schema.default = jsonSchema.default;
+    }
+    if (jsonSchema.example !== undefined) {
+        schema.example = jsonSchema.example;
+    }
+    if (jsonSchema.nullable) {
+        schema.nullable = true;
+    }
+    // Handle anyOf/oneOf as anyOf in GenAI
+    if (jsonSchema.anyOf) {
+        schema.anyOf = jsonSchema.anyOf.map((s) => jsonSchemaToGenAISchema(s));
+    }
+    else if (jsonSchema.oneOf) {
+        schema.anyOf = jsonSchema.oneOf.map((s) => jsonSchemaToGenAISchema(s));
+    }
+    // Handle number/string specific properties
+    if (jsonSchema.minimum !== undefined) {
+        schema.minimum = jsonSchema.minimum;
+    }
+    if (jsonSchema.maximum !== undefined) {
+        schema.maximum = jsonSchema.maximum;
+    }
+    if (jsonSchema.minLength !== undefined) {
+        schema.minLength = jsonSchema.minLength;
+    }
+    if (jsonSchema.maxLength !== undefined) {
+        schema.maxLength = jsonSchema.maxLength;
+    }
+    if (jsonSchema.pattern) {
+        schema.pattern = jsonSchema.pattern;
+    }
+    return schema;
+}
+/**
+ * Convert AI SDK Tool to GenAI FunctionDeclaration
+ */
+export function aiToolToGenAIFunction(tool) {
+    // Extract the input schema - assume it's a Zod schema
+    const inputSchema = tool.inputSchema;
+    // Get the tool name from the schema or generate one
+    let toolName = 'tool';
+    let jsonSchema = {};
+    if (inputSchema) {
+        // Convert Zod schema to JSON Schema
+        jsonSchema = toJSONSchema(inputSchema);
+        // Extract name from Zod description if available
+        const description = inputSchema.description;
+        if (description) {
+            const nameMatch = description.match(/name:\s*(\w+)/);
+            if (nameMatch) {
+                toolName = nameMatch[1] || '';
+            }
+        }
+    }
+    // Convert JSON Schema to GenAI Schema
+    const genAISchema = jsonSchemaToGenAISchema(jsonSchema);
+    // Create the FunctionDeclaration
+    const functionDeclaration = {
+        name: toolName,
+        description: tool.description || jsonSchema.description || 'Tool function',
+        parameters: genAISchema,
+    };
+    return functionDeclaration;
+}
+/**
+ * Convert AI SDK Tool to GenAI CallableTool
+ */
+export function aiToolToCallableTool(tool, name) {
+    const toolName = name || 'tool';
+    return {
+        name,
+        async tool() {
+            const functionDeclaration = aiToolToGenAIFunction(tool);
+            if (name) {
+                functionDeclaration.name = name;
+            }
+            return {
+                functionDeclarations: [functionDeclaration],
+            };
+        },
+        async callTool(functionCalls) {
+            const parts = [];
+            for (const functionCall of functionCalls) {
+                // Check if this function call matches our tool
+                if (functionCall.name !== toolName &&
+                    name &&
+                    functionCall.name !== name) {
+                    continue;
+                }
+                // Execute the tool if it has an execute function
+                if (tool.execute) {
+                    try {
+                        const result = await tool.execute(functionCall.args || {}, {
+                            toolCallId: functionCall.id || '',
+                            messages: [],
+                        });
+                        // Convert the result to a Part
+                        parts.push({
+                            functionResponse: {
+                                id: functionCall.id,
+                                name: functionCall.name || toolName,
+                                response: {
+                                    output: result,
+                                },
+                            },
+                        });
+                    }
+                    catch (error) {
+                        // Handle errors
+                        parts.push({
+                            functionResponse: {
+                                id: functionCall.id,
+                                name: functionCall.name || toolName,
+                                response: {
+                                    error: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        });
+                    }
+                }
+            }
+            return parts;
+        },
+    };
+}
+/**
+ * Helper to extract schema from AI SDK tool
+ */
+export function extractSchemaFromTool(tool) {
+    const inputSchema = tool.inputSchema;
+    if (!inputSchema) {
+        return {};
+    }
+    // Convert Zod schema to JSON Schema
+    return toJSONSchema(inputSchema);
+}
+/**
+ * Given an object of tools, creates an array of CallableTool
+ */
+export function callableToolsFromObject(tools) {
+    return Object.entries(tools).map(([name, tool]) => aiToolToCallableTool(tool, name));
+}

package/dist/ai-tool-to-genai.test.js

@@ -0,0 +1,267 @@
+import { describe, it, expect } from 'vitest';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Type } from '@google/genai';
+import { aiToolToGenAIFunction, aiToolToCallableTool, extractSchemaFromTool, } from './ai-tool-to-genai.js';
+describe('AI Tool to GenAI Conversion', () => {
+    it('should convert a simple Zod-based tool', () => {
+        const weatherTool = tool({
+            description: 'Get the current weather for a location',
+            inputSchema: z.object({
+                location: z.string().describe('The city name'),
+                unit: z.enum(['celsius', 'fahrenheit']).optional(),
+            }),
+            execute: async ({ location, unit }) => {
+                return {
+                    temperature: 72,
+                    unit: unit || 'fahrenheit',
+                    condition: 'sunny',
+                };
+            },
+        });
+        const genAIFunction = aiToolToGenAIFunction(weatherTool);
+        expect(genAIFunction).toMatchInlineSnapshot(`
+      {
+        "description": "Get the current weather for a location",
+        "name": "tool",
+        "parameters": {
+          "properties": {
+            "location": {
+              "description": "The city name",
+              "type": "STRING",
+            },
+            "unit": {
+              "enum": [
+                "celsius",
+                "fahrenheit",
+              ],
+              "type": "STRING",
+            },
+          },
+          "required": [
+            "location",
+          ],
+          "type": "OBJECT",
+        },
+      }
+    `);
+    });
+    it('should handle complex nested schemas', () => {
+        const complexTool = tool({
+            description: 'Process complex data',
+            inputSchema: z.object({
+                user: z.object({
+                    name: z.string(),
+                    age: z.number().int().min(0).max(150),
+                    email: z.string().email(),
+                }),
+                preferences: z.array(z.string()),
+                metadata: z.record(z.string(), z.unknown()).optional(),
+            }),
+            execute: async (input) => input,
+        });
+        const genAIFunction = aiToolToGenAIFunction(complexTool);
+        expect(genAIFunction.parameters).toMatchInlineSnapshot(`
+      {
+        "properties": {
+          "metadata": {
+            "type": "OBJECT",
+          },
+          "preferences": {
+            "items": {
+              "type": "STRING",
+            },
+            "type": "ARRAY",
+          },
+          "user": {
+            "properties": {
+              "age": {
+                "format": "int32",
+                "maximum": 150,
+                "minimum": 0,
+                "type": "INTEGER",
+              },
+              "email": {
+                "pattern": "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$",
+                "type": "STRING",
+              },
+              "name": {
+                "type": "STRING",
+              },
+            },
+            "required": [
+              "name",
+              "age",
+              "email",
+            ],
+            "type": "OBJECT",
+          },
+        },
+        "required": [
+          "user",
+          "preferences",
+        ],
+        "type": "OBJECT",
+      }
+    `);
+    });
+    it('should extract schema from tool', () => {
+        const testTool = tool({
+            inputSchema: z.object({
+                test: z.string(),
+            }),
+            execute: async () => { },
+        });
+        const schema = extractSchemaFromTool(testTool);
+        expect(schema).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "additionalProperties": false,
+        "properties": {
+          "test": {
+            "type": "string",
+          },
+        },
+        "required": [
+          "test",
+        ],
+        "type": "object",
+      }
+    `);
+    });
+    it('should handle tools with no input schema', () => {
+        const simpleTool = tool({
+            description: 'Simple tool with no inputs',
+            inputSchema: z.object({}),
+            execute: async () => ({ result: 'done' }),
+        });
+        const genAIFunction = aiToolToGenAIFunction(simpleTool);
+        expect(genAIFunction).toMatchInlineSnapshot(`
+      {
+        "description": "Simple tool with no inputs",
+        "name": "tool",
+        "parameters": {
+          "properties": {},
+          "type": "OBJECT",
+        },
+      }
+    `);
+    });
+    it('should handle union types', () => {
+        const unionTool = tool({
+            description: 'Tool with union types',
+            inputSchema: z.object({
+                value: z.union([z.string(), z.number(), z.boolean()]),
+            }),
+            execute: async ({ value }) => ({ received: value }),
+        });
+        const genAIFunction = aiToolToGenAIFunction(unionTool);
+        expect(genAIFunction.parameters?.properties?.value).toMatchInlineSnapshot(`
+      {
+        "anyOf": [
+          {
+            "type": "STRING",
+          },
+          {
+            "format": "float",
+            "type": "NUMBER",
+          },
+          {
+            "type": "BOOLEAN",
+          },
+        ],
+      }
+    `);
+    });
+    it('should create a CallableTool', async () => {
+        const weatherTool = tool({
+            description: 'Get weather',
+            inputSchema: z.object({
+                location: z.string(),
+            }),
+            execute: async ({ location }) => ({
+                temperature: 72,
+                location,
+            }),
+        });
+        const callableTool = aiToolToCallableTool(weatherTool, 'weather');
+        // Test tool() method
+        const genAITool = await callableTool.tool();
+        expect(genAITool.functionDeclarations).toMatchInlineSnapshot(`
+      [
+        {
+          "description": "Get weather",
+          "name": "weather",
+          "parameters": {
+            "properties": {
+              "location": {
+                "type": "STRING",
+              },
+            },
+            "required": [
+              "location",
+            ],
+            "type": "OBJECT",
+          },
+        },
+      ]
+    `);
+        // Test callTool() method
+        const functionCall = {
+            id: 'call_123',
+            name: 'weather',
+            args: { location: 'San Francisco' },
+        };
+        const parts = await callableTool.callTool([functionCall]);
+        expect(parts).toMatchInlineSnapshot(`
+      [
+        {
+          "functionResponse": {
+            "id": "call_123",
+            "name": "weather",
+            "response": {
+              "output": {
+                "location": "San Francisco",
+                "temperature": 72,
+              },
+            },
+          },
+        },
+      ]
+    `);
+    });
+    it('should handle tool execution errors', async () => {
+        const errorTool = tool({
+            description: 'Tool that throws',
+            inputSchema: z.object({
+                trigger: z.boolean(),
+            }),
+            execute: async ({ trigger }) => {
+                if (trigger) {
+                    throw new Error('Tool execution failed');
+                }
+                return { success: true };
+            },
+        });
+        const callableTool = aiToolToCallableTool(errorTool, 'error_tool');
+        const functionCall = {
+            id: 'call_error',
+            name: 'error_tool',
+            args: { trigger: true },
+        };
+        const parts = await callableTool.callTool([functionCall]);
+        expect(parts).toMatchInlineSnapshot(`
+      [
+        {
+          "functionResponse": {
+            "id": "call_error",
+            "name": "error_tool",
+            "response": {
+              "error": "Tool execution failed",
+            },
+          },
+        },
+      ]
+    `);
+    });
+});