@k2wanko/gemini-cli-sdk 0.4.0 → 0.5.0

package/dist/agent.js

@@ -35,6 +35,7 @@ export class GeminiAgent {
             policyEngineConfig: {
                 defaultDecision: PolicyDecision.ALLOW,
             },
+            disableLoopDetection: true,
             compressionThreshold: options.compressionThreshold,
         };
         this.config = new Config(configParams);

package/dist/codemode.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { type ToolDef } from "./tool.js";
+export interface ExecuteResult {
+    result: unknown;
+    error?: string;
+    logs?: string[];
+}
+export interface Executor {
+    execute(code: string, fns: Record<string, (...args: unknown[]) => Promise<unknown>>): Promise<ExecuteResult>;
+}
+export declare class NodeVMExecutor implements Executor {
+    execute(code: string, fns: Record<string, (...args: unknown[]) => Promise<unknown>>): Promise<ExecuteResult>;
+}
+export declare function createCodeModeTool(options: {
+    tools: ToolDef<any>[];
+    executor?: Executor;
+    description?: string;
+}): ToolDef<z.ZodObject<{
+    code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+}, {
+    code: string;
+}>>;

package/dist/codemode.js

@@ -0,0 +1,163 @@
+import { debugLogger } from "@google/gemini-cli-core";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { defineTool } from "./tool.js";
+// ---------------------------------------------------------------------------
+// JSON Schema -> TypeScript type string conversion
+// ---------------------------------------------------------------------------
+function jsonSchemaToTs(schema, depth = 0) {
+    if (schema.enum) {
+        return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    if (schema.anyOf ?? schema.oneOf) {
+        const variants = (schema.anyOf ?? schema.oneOf ?? []).map((s) => jsonSchemaToTs(s, depth));
+        return variants.join(" | ");
+    }
+    const types = Array.isArray(schema.type)
+        ? schema.type
+        : schema.type
+            ? [schema.type]
+            : [];
+    if (types.includes("string"))
+        return "string";
+    if (types.includes("number") || types.includes("integer"))
+        return "number";
+    if (types.includes("boolean"))
+        return "boolean";
+    if (types.includes("null"))
+        return "null";
+    if (types.includes("array") || schema.items) {
+        const items = schema.items
+            ? jsonSchemaToTs(schema.items, depth)
+            : "unknown";
+        return `${items}[]`;
+    }
+    if (types.includes("object") || schema.properties) {
+        const props = schema.properties ?? {};
+        const required = new Set(schema.required ?? []);
+        const indent = "  ".repeat(depth + 1);
+        const closing = "  ".repeat(depth);
+        const entries = Object.entries(props).map(([key, val]) => {
+            const opt = required.has(key) ? "" : "?";
+            const comment = val.description ? `/** ${val.description} */ ` : "";
+            return `${indent}${comment}${key}${opt}: ${jsonSchemaToTs(val, depth + 1)}`;
+        });
+        if (entries.length === 0)
+            return "Record<string, unknown>";
+        return `{\n${entries.join(";\n")};\n${closing}}`;
+    }
+    return "unknown";
+}
+// ---------------------------------------------------------------------------
+// API docs generation from ToolDef array (JSDoc-style, for LLM consumption)
+// ---------------------------------------------------------------------------
+function jsonSchemaToParams(schema, prefix = "") {
+    const props = schema.properties ?? {};
+    const required = new Set(schema.required ?? []);
+    return Object.entries(props).map(([key, val]) => {
+        const opt = required.has(key) ? "" : "?";
+        const type = jsonSchemaToTs(val);
+        const desc = val.description ? ` — ${val.description}` : "";
+        return `//   ${prefix}${key}${opt}: ${type}${desc}`;
+    });
+}
+function generateApiDocs(tools) {
+    debugLogger.debug?.("[codemode] generateApiDocs: %d tools", tools.length);
+    const sections = tools.map((tool) => {
+        const schema = zodToJsonSchema(tool.inputSchema);
+        const params = jsonSchemaToParams(schema);
+        const desc = tool.description ? ` — ${tool.description}` : "";
+        const lines = [`// codemode.${tool.name}(input)${desc}`, ...params];
+        return lines.join("\n");
+    });
+    return sections.join("\n//\n");
+}
+// ---------------------------------------------------------------------------
+// NodeVMExecutor
+// ---------------------------------------------------------------------------
+export class NodeVMExecutor {
+    async execute(code, fns) {
+        debugLogger.debug?.("[codemode:executor] execute called, code length=%d, available fns=%s", code.length, Object.keys(fns).join(", "));
+        debugLogger.debug?.("[codemode:executor] code:\n%s", code);
+        const logs = [];
+        const stringify = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : String(v);
+        const captureConsole = {
+            log: (...args) => logs.push(args.map(stringify).join(" ")),
+            warn: (...args) => logs.push(`[warn] ${args.map(stringify).join(" ")}`),
+            error: (...args) => logs.push(`[error] ${args.map(stringify).join(" ")}`),
+        };
+        try {
+            const AsyncFunction = Object.getPrototypeOf(async () => { })
+                .constructor;
+            const fn = new AsyncFunction("codemode", "console", code);
+            debugLogger.debug?.("[codemode:executor] starting execution");
+            const result = await fn(fns, captureConsole);
+            debugLogger.debug?.("[codemode:executor] execution completed, result=%s, logs=%d", typeof result, logs.length);
+            return {
+                result,
+                logs: logs.length > 0 ? logs : undefined,
+            };
+        }
+        catch (error) {
+            debugLogger.debug?.("[codemode:executor] execution failed: %s", error instanceof Error ? error.message : String(error));
+            return {
+                result: undefined,
+                error: error instanceof Error ? error.message : String(error),
+                logs: logs.length > 0 ? logs : undefined,
+            };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// createCodeModeTool
+// ---------------------------------------------------------------------------
+export function createCodeModeTool(options) {
+    const executor = options.executor ?? new NodeVMExecutor();
+    const apiDocs = generateApiDocs(options.tools);
+    const description = options.description ??
+        `Write and execute plain JavaScript (NOT TypeScript) to orchestrate multiple tools.
+
+The \`codemode\` object exposes all available tools as async functions.
+Always end your code with a \`return\` statement to return the final result.
+
+Available tools:
+\`\`\`javascript
+${apiDocs}
+\`\`\`
+
+Example:
+\`\`\`javascript
+const result = await codemode.toolName({ param: "value" });
+return result;
+\`\`\``;
+    debugLogger.debug?.("[codemode] createCodeModeTool: registering %d tools", options.tools.length);
+    return defineTool({
+        name: "code",
+        description,
+        inputSchema: z.object({
+            code: z
+                .string()
+                .describe("JavaScript code to execute. Must use `return` to return the final result."),
+        }),
+        sendErrorsToModel: true,
+    }, async ({ code }, context) => {
+        debugLogger.debug?.("[codemode] tool invoked, code length=%d", code.length);
+        const fns = {};
+        for (const tool of options.tools) {
+            fns[tool.name] = (input) => {
+                debugLogger.debug?.("[codemode] calling tool '%s' with input: %s", tool.name, JSON.stringify(input));
+                return tool.action(input, context);
+            };
+        }
+        const execResult = await executor.execute(code, fns);
+        const output = {};
+        if (execResult.result !== undefined)
+            output.result = execResult.result;
+        if (execResult.error)
+            output.error = execResult.error;
+        if (execResult.logs && execResult.logs.length > 0)
+            output.logs = execResult.logs;
+        debugLogger.debug?.("[codemode] tool output: %s", JSON.stringify(output));
+        return output;
+    });
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./agent.js";
+export * from "./codemode.js";
 export * from "./context.js";
 export * from "./logger.js";
 export * from "./session.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./agent.js";
+export * from "./codemode.js";
 export * from "./context.js";
 export * from "./logger.js";
 export * from "./session.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k2wanko/gemini-cli-sdk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A lightweight SDK for building non-interactive AI agents powered by Google Gemini",
   "type": "module",
   "private": false,
@@ -38,13 +38,13 @@
   },
   "scripts": {
     "build": "tsc",
-    "lint": "biome check && tsc --noEmit",
-    "fix": "biome check --write . && tsc --noEmit",
+    "lint": "biome check && tsc --noEmit && tsc --project tsconfig.examples.json",
+    "fix": "biome check --write . && tsc --noEmit && tsc --project tsconfig.examples.json",
     "test": "bun test"
   },
   "dependencies": {
     "@a2a-js/sdk": "^0.3.10",
-    "@google/gemini-cli-core": "0.30.0-nightly.20260218.ce84b3cb5",
+    "@google/gemini-cli-core": "nightly",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.1"
   },