@brianli/kimaki 0.4.72-brianli.1

package/src/ai-tool-to-genai.test.ts

@@ -0,0 +1,296 @@
+import { describe, it, expect } from 'vitest'
+import { tool } from './ai-tool.js'
+import { z } from 'zod'
+import { Type } from '@google/genai'
+import type { FunctionDeclaration, FunctionCall } 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: 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: 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/src/ai-tool-to-genai.ts

@@ -0,0 +1,282 @@
+// 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 { AnyTool } from './ai-tool.js'
+import type {
+  FunctionDeclaration,
+  Schema,
+  Tool as GenAITool,
+  CallableTool,
+  FunctionCall,
+  Part,
+} from '@google/genai'
+import { Type } from '@google/genai'
+import { z, toJSONSchema } from 'zod'
+import type { JSONSchema7, JSONSchema7Definition } from 'json-schema'
+
+/**
+ * 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: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+function jsonSchemaToGenAISchema(jsonSchema: JSONSchema7Definition): Schema {
+  const schema: Schema = {}
+
+  if (typeof jsonSchema === 'boolean') {
+    return schema
+  }
+
+  const jsonSchemaType: string | undefined = (() => {
+    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: JSONSchema7Definition | undefined = (() => {
+          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 as unknown
+  }
+  if (Array.isArray(jsonSchema.examples) && jsonSchema.examples.length > 0) {
+    schema.example = jsonSchema.examples[0] as unknown
+  }
+
+  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: AnyTool): FunctionDeclaration {
+  // Extract the input schema - assume it's a Zod schema
+  const inputSchema = tool.inputSchema as z.ZodType<unknown>
+
+  // Get the tool name from the schema or generate one
+  let toolName = 'tool'
+  let jsonSchema: JSONSchema7 = {}
+
+  if (inputSchema) {
+    // Convert Zod schema to JSON Schema
+    jsonSchema = toJSONSchema(inputSchema) as JSONSchema7
+
+    // 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: 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: AnyTool,
+  name: string,
+): CallableTool & { name: string } {
+  const toolName = name || 'tool'
+
+  return {
+    name,
+    async tool(): Promise<GenAITool> {
+      const functionDeclaration = aiToolToGenAIFunction(tool)
+      if (name) {
+        functionDeclaration.name = name
+      }
+
+      return {
+        functionDeclarations: [functionDeclaration],
+      }
+    },
+
+    async callTool(functionCalls: FunctionCall[]): Promise<Part[]> {
+      const parts: Part[] = []
+
+      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: unknown = isRecord(functionCall.args)
+              ? functionCall.args
+              : {}
+            const result = await tool.execute(args, {
+              toolCallId: functionCall.id || '',
+              messages: [],
+            })
+
+            // Convert the result to a Part
+            const part: Part = {
+              functionResponse: {
+                id: functionCall.id,
+                name: functionCall.name || toolName,
+                response: {
+                  output: result,
+                },
+              },
+            }
+            parts.push(part)
+          } catch (error) {
+            // Handle errors
+            const part: 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: AnyTool): JSONSchema7 {
+  const inputSchema = tool.inputSchema as z.ZodType<unknown>
+
+  if (!inputSchema) {
+    return {}
+  }
+
+  // Convert Zod schema to JSON Schema
+  return toJSONSchema(inputSchema) as JSONSchema7
+}
+
+/**
+ * Given an object of tools, creates an array of CallableTool
+ */
+export function callableToolsFromObject(
+  tools: Record<string, AnyTool>,
+): Array<CallableTool & { name: string }> {
+  return Object.entries(tools).map(([name, tool]) =>
+    aiToolToCallableTool(tool, name),
+  )
+}

package/src/ai-tool.ts

@@ -0,0 +1,39 @@
+// 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.
+
+import type { z } from 'zod'
+
+export type ToolExecuteOptions = {
+  toolCallId?: string
+  abortSignal?: AbortSignal
+  messages?: unknown[]
+}
+
+type BivariantCallback<Args extends unknown[], Return> = {
+  bivarianceHack(...args: Args): Return
+}['bivarianceHack']
+
+export type Tool<Input, Output> = {
+  description?: string
+  inputSchema: z.ZodType<Input>
+  execute?: BivariantCallback<
+    [input: Input, options: ToolExecuteOptions],
+    Promise<Output> | Output
+  >
+}
+
+export type AnyTool = {
+  description?: string
+  inputSchema: z.ZodTypeAny
+  execute?: BivariantCallback<
+    [input: unknown, options: ToolExecuteOptions],
+    Promise<unknown> | unknown
+  >
+}
+
+export function tool<Input, Output>(
+  definition: Tool<Input, Output>,
+): Tool<Input, Output> {
+  return definition
+}