@polka-codes/core 0.9.85 → 0.9.88

package/dist/_tsup-dts-rollup.d.ts

@@ -122,6 +122,7 @@ declare const configSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         project: z.ZodOptional<z.ZodString>;
         keyFile: z.ZodOptional<z.ZodString>;
         baseUrl: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     defaultProvider: z.ZodOptional<z.ZodString>;
     defaultModel: z.ZodOptional<z.ZodString>;
@@ -211,6 +212,59 @@ declare const configSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         branch: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>]>>>, z.ZodString]>>;
     excludeFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    agent: z.ZodOptional<z.ZodObject<{
+        preset: z.ZodOptional<z.ZodString>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            "goal-directed": "goal-directed";
+            "continuous-improvement": "continuous-improvement";
+        }>>;
+        continueOnCompletion: z.ZodOptional<z.ZodBoolean>;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        requireApprovalFor: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            destructive: "destructive";
+            commits: "commits";
+            all: "all";
+        }>>;
+        autoApproveSafeTasks: z.ZodOptional<z.ZodBoolean>;
+        maxAutoApprovalCost: z.ZodOptional<z.ZodNumber>;
+        pauseOnError: z.ZodOptional<z.ZodBoolean>;
+        workingBranch: z.ZodOptional<z.ZodString>;
+        destructiveOperations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxConcurrency: z.ZodOptional<z.ZodNumber>;
+        autoSaveInterval: z.ZodOptional<z.ZodNumber>;
+        workingDir: z.ZodOptional<z.ZodString>;
+        continuousImprovement: z.ZodOptional<z.ZodObject<{
+            sleepTimeOnNoTasks: z.ZodOptional<z.ZodNumber>;
+            sleepTimeBetweenTasks: z.ZodOptional<z.ZodNumber>;
+            maxCycles: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        discovery: z.ZodOptional<z.ZodObject<{
+            enabledStrategies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cacheTime: z.ZodOptional<z.ZodNumber>;
+            checkChanges: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        safety: z.ZodOptional<z.ZodObject<{
+            enabledChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            blockDestructive: z.ZodOptional<z.ZodBoolean>;
+            maxFileSize: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        healthCheck: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            interval: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        approval: z.ZodOptional<z.ZodObject<{
+            level: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                destructive: "destructive";
+                commits: "commits";
+                all: "all";
+            }>>;
+            autoApproveSafeTasks: z.ZodOptional<z.ZodBoolean>;
+            maxAutoApprovalCost: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>>>;
 export { configSchema }
 export { configSchema as configSchema_alias_1 }
@@ -232,6 +286,18 @@ export { ContinueStepSchema }
 export { ContinueStepSchema as ContinueStepSchema_alias_1 }
 export { ContinueStepSchema as ContinueStepSchema_alias_2 }
 
+/**
+ * Convert a JSON Schema to a Zod schema
+ * Supports a subset of JSON SchemaDraft 7
+ *
+ * This is exported to allow reuse in other parts of the codebase that need to
+ * convert JSON schemas to Zod schemas (e.g., MCP server tool schema conversion).
+ */
+declare function convertJsonSchemaToZod(schema: JsonSchema): z.ZodTypeAny;
+export { convertJsonSchemaToZod }
+export { convertJsonSchemaToZod as convertJsonSchemaToZod_alias_1 }
+export { convertJsonSchemaToZod as convertJsonSchemaToZod_alias_2 }
+
 declare function createContext<TTools extends ToolRegistry>(tools: WorkflowTools<TTools>, stepFn?: StepFn, logger?: Logger): WorkflowContext<TTools>;
 export { createContext }
 export { createContext as createContext_alias_1 }
@@ -242,15 +308,86 @@ export { createDynamicWorkflow }
 export { createDynamicWorkflow as createDynamicWorkflow_alias_1 }
 export { createDynamicWorkflow as createDynamicWorkflow_alias_2 }
 
+/**
+ * Create an error tool response
+ *
+ * @param message - The error message
+ * @returns An error tool response object
+ *
+ * @example
+ * ```ts
+ * return createErrorResponse('Failed to read file')
+ * ```
+ */
+declare function createErrorResponse(message: string): ToolResponse;
+export { createErrorResponse }
+export { createErrorResponse as createErrorResponse_alias_1 }
+export { createErrorResponse as createErrorResponse_alias_2 }
+
 /**
  * Create a file content XML element
  */
 export declare function createFileElement(tagName: string, path: string, content?: string, attrs?: Record<string, string>): string;
 
 /**
- * Create a standardized error response for provider method not available
+ * Create a provider capability error response
+ * Use this when a required provider capability is not available
+ *
+ * @param capability - The capability that's missing (e.g., "read file", "write file")
+ * @returns An error response indicating the missing capability
+ *
+ * @example
+ * ```ts
+ * if (!provider.readFile) {
+ *   return createProviderErrorResponse('read file')
+ * }
+ * ```
+ */
+declare function createProviderErrorResponse(capability: string): ToolResponse;
+export { createProviderErrorResponse as createProviderError }
+export { createProviderErrorResponse }
+export { createProviderErrorResponse as createProviderErrorResponse_alias_1 }
+export { createProviderErrorResponse as createProviderErrorResponse_alias_2 }
+
+/**
+ * Create a successful tool response
+ *
+ * @param value - The response value (string or JSON string)
+ * @param type - Response type ('text' or 'json')
+ * @returns A successful tool response object
+ *
+ * @example
+ * ```ts
+ * return createSuccessResponse('File content loaded')
+ * return createSuccessResponse(JSON.stringify(data), 'json')
+ * ```
+ */
+declare function createSuccessResponse(value: string, type?: 'text' | 'json'): ToolResponse;
+export { createSuccessResponse }
+export { createSuccessResponse as createSuccessResponse_alias_1 }
+export { createSuccessResponse as createSuccessResponse_alias_2 }
+
+/**
+ * Create a validation error response
+ * Use this when input validation fails
+ *
+ * @param errors - The validation error details
+ * @returns An error response with validation details
+ *
+ * @example
+ * ```ts
+ * const result = schema.safeParse(input)
+ * if (!result.success) {
+ *   return createValidationErrorResponse(result.error)
+ * }
+ * ```
  */
-export declare function createProviderError(action: string): ToolResponse;
+declare function createValidationErrorResponse(errors: {
+    message: string;
+}): ToolResponse;
+export { createValidationErrorResponse }
+export { createValidationErrorResponse as createValidationErrorResponse_alias_1 }
+export { createValidationErrorResponse as createValidationErrorResponse_alias_2 }
 
 declare const _default: {
     handler: ToolHandler<{
@@ -884,6 +1021,27 @@ export { JsonResponseMessage }
 export { JsonResponseMessage as JsonResponseMessage_alias_1 }
 export { JsonResponseMessage as JsonResponseMessage_alias_2 }
 
+declare interface JsonSchema {
+    type?: JsonSchemaType | JsonSchemaType[];
+    enum?: JsonSchemaEnum;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    additionalProperties?: boolean | JsonSchema;
+    description?: string;
+    [key: string]: unknown;
+}
+
+/**
+ * JSON Schema enum values - can be string, number, or boolean
+ */
+declare type JsonSchemaEnum = (string | number | boolean)[];
+
+/**
+ * JSON Schema type to Zod type mapping
+ */
+declare type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+
 declare interface JsonToolCallPart {
     type: 'tool-call';
     /**
@@ -1231,6 +1389,7 @@ declare const providerConfigSchema: z.ZodObject<{
     project: z.ZodOptional<z.ZodString>;
     keyFile: z.ZodOptional<z.ZodString>;
     baseUrl: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export { providerConfigSchema }
 export { providerConfigSchema as providerConfigSchema_alias_1 }

package/dist/index.d.ts

@@ -72,6 +72,10 @@ export { readFile } from './_tsup-dts-rollup.js';
 export { removeFile } from './_tsup-dts-rollup.js';
 export { renameFile } from './_tsup-dts-rollup.js';
 export { replaceInFile } from './_tsup-dts-rollup.js';
+export { createErrorResponse } from './_tsup-dts-rollup.js';
+export { createProviderErrorResponse } from './_tsup-dts-rollup.js';
+export { createSuccessResponse } from './_tsup-dts-rollup.js';
+export { createValidationErrorResponse } from './_tsup-dts-rollup.js';
 export { search } from './_tsup-dts-rollup.js';
 export { searchFiles } from './_tsup-dts-rollup.js';
 export { writeToFile } from './_tsup-dts-rollup.js';
@@ -97,6 +101,7 @@ export { UsageMeter_alias_1 as UsageMeter } from './_tsup-dts-rollup.js';
 export { AgentWorkflowInput } from './_tsup-dts-rollup.js';
 export { AgentToolRegistry } from './_tsup-dts-rollup.js';
 export { agentWorkflow } from './_tsup-dts-rollup.js';
+export { convertJsonSchemaToZod } from './_tsup-dts-rollup.js';
 export { validateWorkflowFile } from './_tsup-dts-rollup.js';
 export { parseDynamicWorkflowDefinition } from './_tsup-dts-rollup.js';
 export { createDynamicWorkflow } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -146,7 +146,9 @@ var providerConfigSchema = z.object({
   location: z.string().optional(),
   project: z.string().optional(),
   keyFile: z.string().optional(),
-  baseUrl: z.string().optional()
+  baseUrl: z.string().optional(),
+  name: z.string().optional()
+  // For OpenAI-compatible providers
 });
 var providerModelSchema = z.object({
   provider: z.string().optional(),
@@ -202,6 +204,51 @@ var mcpServerConfigSchema = z.object({
     )
   ).optional()
 }).strict();
+var agentContinuousImprovementSchema = z.object({
+  sleepTimeOnNoTasks: z.number().int().optional(),
+  sleepTimeBetweenTasks: z.number().int().optional(),
+  maxCycles: z.number().int().optional()
+}).strict().optional();
+var agentDiscoverySchema = z.object({
+  enabledStrategies: z.array(z.string()).optional(),
+  cacheTime: z.number().int().optional(),
+  checkChanges: z.boolean().optional()
+}).strict().optional();
+var agentSafetySchema = z.object({
+  enabledChecks: z.array(z.string()).optional(),
+  blockDestructive: z.boolean().optional(),
+  maxFileSize: z.number().int().optional()
+}).strict().optional();
+var agentHealthCheckSchema = z.object({
+  enabled: z.boolean().optional(),
+  interval: z.number().int().optional()
+}).strict().optional();
+var agentApprovalSchema = z.object({
+  level: z.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApproveSafeTasks: z.boolean().optional(),
+  maxAutoApprovalCost: z.number().optional()
+}).strict().optional();
+var agentSchema = z.object({
+  preset: z.string().optional(),
+  strategy: z.enum(["goal-directed", "continuous-improvement"]).optional(),
+  continueOnCompletion: z.boolean().optional(),
+  maxIterations: z.number().int().optional(),
+  timeout: z.number().int().optional(),
+  requireApprovalFor: z.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApproveSafeTasks: z.boolean().optional(),
+  maxAutoApprovalCost: z.number().optional(),
+  pauseOnError: z.boolean().optional(),
+  workingBranch: z.string().optional(),
+  destructiveOperations: z.array(z.string()).optional(),
+  maxConcurrency: z.number().int().optional(),
+  autoSaveInterval: z.number().int().optional(),
+  workingDir: z.string().optional(),
+  continuousImprovement: agentContinuousImprovementSchema,
+  discovery: agentDiscoverySchema,
+  safety: agentSafetySchema,
+  healthCheck: agentHealthCheckSchema,
+  approval: agentApprovalSchema
+}).strict().optional();
 var configSchema = z.object({
   prices: z.record(
     z.string(),
@@ -233,7 +280,8 @@ var configSchema = z.object({
   }).optional(),
   mcpServers: z.record(z.string(), mcpServerConfigSchema).optional(),
   rules: z.array(ruleSchema).optional().or(z.string()).optional(),
-  excludeFiles: z.array(z.string()).optional()
+  excludeFiles: z.array(z.string()).optional(),
+  agent: agentSchema
 }).strict().nullish();
 
 // src/fs/node-provider.ts
@@ -999,16 +1047,39 @@ var askFollowupQuestion_default = {
 // src/tools/executeCommand.ts
 import { z as z7 } from "zod";
 
-// src/tools/utils.ts
-function createProviderError(action) {
+// src/tools/response-builders.ts
+function createSuccessResponse(value, type = "text") {
+  return {
+    success: true,
+    message: { type, value }
+  };
+}
+function createErrorResponse(message) {
+  return {
+    success: false,
+    message: { type: "error-text", value: message }
+  };
+}
+function createProviderErrorResponse(capability) {
   return {
     success: false,
     message: {
       type: "error-text",
-      value: `Not possible to ${action}.`
+      value: `Not possible to ${capability}.`
     }
   };
 }
+function createValidationErrorResponse(errors) {
+  return {
+    success: false,
+    message: {
+      type: "error-text",
+      value: `Validation failed: ${errors.message}`
+    }
+  };
+}
+
+// src/tools/utils.ts
 function preprocessBoolean(val) {
   return typeof val === "string" ? val.toLowerCase() === "true" : val;
 }
@@ -1048,7 +1119,7 @@ var toolInfo2 = {
 };
 var handler2 = async (provider, args) => {
   if (!provider.executeCommand) {
-    return createProviderError("execute command. Abort");
+    return createProviderErrorResponse("execute command. Abort");
   }
   const { command, requiresApproval } = toolInfo2.parameters.parse(args);
   try {
@@ -1203,7 +1274,7 @@ var toolInfo4 = {
 };
 var handler4 = async (provider, args) => {
   if (!provider.listFiles) {
-    return createProviderError("list files");
+    return createProviderErrorResponse("list files");
   }
   const { path, maxCount, recursive, includeIgnored } = toolInfo4.parameters.parse(args);
   const [files, limitReached] = await provider.listFiles(path, recursive, maxCount, includeIgnored);
@@ -1368,7 +1439,7 @@ var toolInfo6 = {
 };
 var handler6 = async (provider, args) => {
   if (!provider.readFile) {
-    return createProviderError("read file");
+    return createProviderErrorResponse("read file");
   }
   const { path: paths, includeIgnored } = toolInfo6.parameters.parse(args);
   const resp = [];
@@ -1413,7 +1484,7 @@ var toolInfo7 = {
 };
 var handler7 = async (provider, args) => {
   if (!provider.removeFile) {
-    return createProviderError("remove file");
+    return createProviderErrorResponse("remove file");
   }
   const parsed = toolInfo7.parameters.safeParse(args);
   if (!parsed.success) {
@@ -1980,7 +2051,7 @@ export default App;
 };
 var handler12 = async (provider, args) => {
   if (!provider.writeFile) {
-    return createProviderError("write file");
+    return createProviderErrorResponse("write file");
   }
   const parsed = toolInfo12.parameters.safeParse(args);
   if (!parsed.success) {
@@ -2403,8 +2474,18 @@ var WorkflowFileSchema = z20.object({
 var MAX_WHILE_LOOP_ITERATIONS = 1e3;
 function convertJsonSchemaToZod(schema) {
   if (schema.enum) {
-    const enumValues = schema.enum.map((v) => String(v));
-    return z21.enum(enumValues);
+    const enumValues = schema.enum;
+    if (enumValues.length === 0) {
+      return z21.never();
+    }
+    if (enumValues.every((v) => typeof v === "string")) {
+      return z21.enum(enumValues);
+    }
+    const literals = enumValues.map((v) => z21.literal(v));
+    if (literals.length === 1) {
+      return literals[0];
+    }
+    return z21.union([literals[0], literals[1], ...literals.slice(2)]);
   }
   if (Array.isArray(schema.type)) {
     const types = schema.type;
@@ -2573,8 +2654,13 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
   }
   return validatedInput;
 }
-function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false) {
+function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false, logger) {
   if (allowUnsafeCodeExecution) {
+    if (logger) {
+      logger.warn(
+        `[SECURITY] Executing unsafe code evaluation for condition: ${condition}. This allows arbitrary JavaScript execution and should only be used for trusted workflows.`
+      );
+    }
     const functionBody = `
       try {
         return ${condition};
@@ -3466,8 +3552,13 @@ export {
   askFollowupQuestion_default as askFollowupQuestion,
   computeRateLimitBackoffSeconds,
   configSchema,
+  convertJsonSchemaToZod,
   createContext,
   createDynamicWorkflow,
+  createErrorResponse,
+  createProviderErrorResponse,
+  createSuccessResponse,
+  createValidationErrorResponse,
   executeCommand_default as executeCommand,
   fetchUrl_default as fetchUrl,
   fromJsonModelMessage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/core",
-  "version": "0.9.85",
+  "version": "0.9.88",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",