@brianli/kimaki 0.4.72-brianli.1

package/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './dist/bin.js'

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

@@ -0,0 +1,233 @@
+// Tool definition to Google GenAI tool converter.
+// Transforms Kimaki's minimal Tool definitions into Google GenAI CallableTool format
+// for use with Gemini's function calling in the voice assistant.
+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 isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function jsonSchemaToGenAISchema(jsonSchema) {
+    const schema = {};
+    if (typeof jsonSchema === 'boolean') {
+        return schema;
+    }
+    const jsonSchemaType = (() => {
+        if (!jsonSchema.type) {
+            return undefined;
+        }
+        if (typeof jsonSchema.type === 'string') {
+            return jsonSchema.type;
+        }
+        if (Array.isArray(jsonSchema.type)) {
+            return jsonSchema.type.find((t) => t !== 'null') || jsonSchema.type[0];
+        }
+        return undefined;
+    })();
+    if (Array.isArray(jsonSchema.type) && jsonSchema.type.includes('null')) {
+        schema.nullable = true;
+    }
+    if (jsonSchemaType) {
+        switch (jsonSchemaType) {
+            case 'string':
+                schema.type = Type.STRING;
+                break;
+            case 'number':
+                schema.type = Type.NUMBER;
+                schema.format =
+                    typeof jsonSchema.format === 'string' ? jsonSchema.format : 'float';
+                break;
+            case 'integer':
+                schema.type = Type.INTEGER;
+                schema.format =
+                    typeof jsonSchema.format === 'string' ? jsonSchema.format : 'int32';
+                break;
+            case 'boolean':
+                schema.type = Type.BOOLEAN;
+                break;
+            case 'array': {
+                schema.type = Type.ARRAY;
+                const itemsSchema = (() => {
+                    if (!jsonSchema.items) {
+                        return undefined;
+                    }
+                    if (Array.isArray(jsonSchema.items)) {
+                        return jsonSchema.items[0];
+                    }
+                    return jsonSchema.items;
+                })();
+                if (itemsSchema) {
+                    schema.items = jsonSchemaToGenAISchema(itemsSchema);
+                }
+                if (typeof jsonSchema.minItems === 'number') {
+                    schema.minItems = String(jsonSchema.minItems);
+                }
+                if (typeof jsonSchema.maxItems === 'number') {
+                    schema.maxItems = String(jsonSchema.maxItems);
+                }
+                break;
+            }
+            case 'object':
+                schema.type = Type.OBJECT;
+                if (jsonSchema.properties) {
+                    schema.properties = Object.fromEntries(Object.entries(jsonSchema.properties).map(([key, value]) => [
+                        key,
+                        jsonSchemaToGenAISchema(value),
+                    ]));
+                }
+                if (Array.isArray(jsonSchema.required)) {
+                    schema.required = jsonSchema.required;
+                }
+                break;
+        }
+    }
+    if (typeof jsonSchema.description === 'string') {
+        schema.description = jsonSchema.description;
+    }
+    if (Array.isArray(jsonSchema.enum)) {
+        schema.enum = jsonSchema.enum.map((x) => String(x));
+    }
+    if ('default' in jsonSchema) {
+        schema.default = jsonSchema.default;
+    }
+    if (Array.isArray(jsonSchema.examples) && jsonSchema.examples.length > 0) {
+        schema.example = jsonSchema.examples[0];
+    }
+    if (Array.isArray(jsonSchema.anyOf)) {
+        schema.anyOf = jsonSchema.anyOf.map((s) => jsonSchemaToGenAISchema(s));
+    }
+    else if (Array.isArray(jsonSchema.oneOf)) {
+        schema.anyOf = jsonSchema.oneOf.map((s) => jsonSchemaToGenAISchema(s));
+    }
+    if (typeof jsonSchema.minimum === 'number') {
+        schema.minimum = jsonSchema.minimum;
+    }
+    if (typeof jsonSchema.maximum === 'number') {
+        schema.maximum = jsonSchema.maximum;
+    }
+    if (typeof jsonSchema.minLength === 'number') {
+        schema.minLength = String(jsonSchema.minLength);
+    }
+    if (typeof jsonSchema.maxLength === 'number') {
+        schema.maxLength = String(jsonSchema.maxLength);
+    }
+    if (typeof jsonSchema.pattern === 'string') {
+        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 args = isRecord(functionCall.args)
+                            ? functionCall.args
+                            : {};
+                        const result = await tool.execute(args, {
+                            toolCallId: functionCall.id || '',
+                            messages: [],
+                        });
+                        // Convert the result to a Part
+                        const part = {
+                            functionResponse: {
+                                id: functionCall.id,
+                                name: functionCall.name || toolName,
+                                response: {
+                                    output: result,
+                                },
+                            },
+                        };
+                        parts.push(part);
+                    }
+                    catch (error) {
+                        // Handle errors
+                        const part = {
+                            functionResponse: {
+                                id: functionCall.id,
+                                name: functionCall.name || toolName,
+                                response: {
+                                    error: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        };
+                        parts.push(part);
+                    }
+                }
+            }
+            return parts;
+        },
+    };
+}
+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-tool.js';
+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",
+            },
+          },
+        },
+      ]
+    `);
+    });
+});

package/dist/ai-tool.js

@@ -0,0 +1,6 @@
+// Minimal tool definition helper used by Kimaki.
+// This replaces the Vercel AI SDK `tool()` helper so Kimaki can define typed
+// tools (Zod input schema + execute) without depending on the full `ai` package.
+export function tool(definition) {
+    return definition;
+}

package/dist/bin.js

@@ -0,0 +1,87 @@
+// Respawn wrapper for the kimaki bot process.
+// When running the default command (no subcommand) with --auto-restart,
+// spawns cli.js as a child process and restarts it on non-zero exit codes
+// (crash, OOM kill, etc). Intentional exits (code 0 or EXIT_NO_RESTART=64)
+// are not restarted.
+//
+// Subcommands (send, tunnel, project, etc.) run directly without the wrapper
+// since they are short-lived and don't need crash recovery.
+//
+// When __KIMAKI_CHILD is set, we're the child process -- just run cli.js directly.
+//
+// V8 heap snapshot flags:
+// Injects --heapsnapshot-near-heap-limit=3 and --diagnostic-dir so V8 writes
+// heap snapshots internally as it approaches the heap limit. This catches OOM
+// situations where SIGKILL (exit 137) would kill the process before our
+// heap-monitor.ts polling can react. The polling monitor is kept as an early
+// warning system at 85% usage; the V8 flag is the last-resort safety net.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const HEAP_SNAPSHOT_DIR = path.join(os.homedir(), '.kimaki', 'heap-snapshots');
+// First arg after node + script is either a subcommand or a flag.
+// If it doesn't start with '-', it's a subcommand (e.g. "send", "tunnel", "project").
+const firstArg = process.argv[2];
+const isSubcommand = firstArg && !firstArg.startsWith('-');
+const hasAutoRestart = process.argv.includes('--auto-restart');
+if (process.env.__KIMAKI_CHILD || isSubcommand || !hasAutoRestart) {
+    await import('./cli.js');
+}
+else {
+    const EXIT_NO_RESTART = 64;
+    const MAX_RAPID_RESTARTS = 5;
+    const RAPID_RESTART_WINDOW_MS = 60_000;
+    const RESTART_DELAY_MS = 2_000;
+    const restartTimestamps = [];
+    let child = null;
+    // Track when we forwarded a termination signal so we don't restart after graceful shutdown
+    let shutdownRequested = false;
+    function start() {
+        if (!fs.existsSync(HEAP_SNAPSHOT_DIR)) {
+            fs.mkdirSync(HEAP_SNAPSHOT_DIR, { recursive: true });
+        }
+        const heapArgs = [
+            `--heapsnapshot-near-heap-limit=3`,
+            `--diagnostic-dir=${HEAP_SNAPSHOT_DIR}`,
+        ];
+        child = spawn(process.argv[0], [...heapArgs, ...process.execArgv, ...process.argv.slice(1)], {
+            stdio: 'inherit',
+            env: { ...process.env, __KIMAKI_CHILD: '1' },
+        });
+        child.on('exit', (code, signal) => {
+            if (code === 0 || code === EXIT_NO_RESTART || shutdownRequested) {
+                process.exit(code ?? 0);
+                return;
+            }
+            const now = Date.now();
+            restartTimestamps.push(now);
+            while (restartTimestamps.length > 0 &&
+                restartTimestamps[0] < now - RAPID_RESTART_WINDOW_MS) {
+                restartTimestamps.shift();
+            }
+            if (restartTimestamps.length > MAX_RAPID_RESTARTS) {
+                console.error(`[kimaki] Crash loop detected (${MAX_RAPID_RESTARTS} crashes in ${RAPID_RESTART_WINDOW_MS / 1000}s), exiting`);
+                process.exit(1);
+                return;
+            }
+            const reason = signal ? `signal ${signal}` : `code ${code}`;
+            console.error(`[kimaki] Process exited with ${reason}, restarting in ${RESTART_DELAY_MS / 1000}s...`);
+            setTimeout(start, RESTART_DELAY_MS);
+        });
+    }
+    // Forward signals to child so graceful shutdown and heap snapshots work.
+    // SIGTERM/SIGINT mark shutdownRequested so we don't restart after graceful exit.
+    for (const sig of ['SIGTERM', 'SIGINT']) {
+        process.on(sig, () => {
+            shutdownRequested = true;
+            child?.kill(sig);
+        });
+    }
+    for (const sig of ['SIGUSR1', 'SIGUSR2']) {
+        process.on(sig, () => {
+            child?.kill(sig);
+        });
+    }
+    start();
+}