botinabox 2.10.1 → 2.12.0

package/dist/connectors/google/index.js

@@ -156,22 +156,30 @@ var GoogleCalendarConnector = class {
       errors
     };
   }
-  /** Full sync using timeMin. */
+  /**
+   * Full sync — paginates through every event for the calendar to obtain a
+   * `nextSyncToken`. Google only emits `nextSyncToken` on the final page of a
+   * query that contains none of `timeMin`, `timeMax`, `orderBy`, `q`,
+   * `updatedMin`, `eventTypes`, `iCalUID`, `showDeleted`, or
+   * `showHiddenInvitations`. This implementation therefore omits all of those
+   * parameters and drains pagination to completion regardless of `options.limit`
+   * or `options.since` — a partial first sync would never mint a usable cursor,
+   * which would break every subsequent `syncIncremental` call.
+   *
+   * `options.limit` and `options.since` are intentionally ignored on full sync.
+   * Use `syncIncremental` (via `options.cursor`) for bounded follow-up syncs.
+   */
   async syncFull(options) {
     const calendarId = options?.filters?.calendarId ?? "primary";
     const records = [];
     const errors = [];
-    const maxResults = options?.limit ?? 250;
-    const timeMin = options?.since ? new Date(options.since).toISOString() : new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString();
     let pageToken;
     let nextSyncToken;
     do {
       const res = await this.calendar.events.list({
         calendarId,
-        timeMin,
         singleEvents: true,
-        orderBy: "startTime",
-        maxResults: Math.min(maxResults - records.length, 250),
+        maxResults: 250,
         ...pageToken ? { pageToken } : {}
       });
       for (const event of res.data.items ?? []) {
@@ -180,15 +188,14 @@ var GoogleCalendarConnector = class {
         } catch (err) {
           errors.push({ id: event.id, error: errorMessage(err) });
         }
-        if (records.length >= maxResults) break;
       }
       pageToken = res.data.nextPageToken ?? void 0;
       nextSyncToken = res.data.nextSyncToken ?? void 0;
-    } while (pageToken && records.length < maxResults);
+    } while (pageToken);
     return {
       records,
       cursor: nextSyncToken,
-      hasMore: !!pageToken,
+      hasMore: false,
       errors
     };
   }

package/dist/core/orchestrator/execution-engine.d.ts

@@ -98,6 +98,17 @@ export interface ExecutionEngineConfig {
         agent: Record<string, unknown>;
         task: Record<string, unknown>;
     }) => string | undefined;
+    /**
+     * Mark the system prompt as ephemerally cacheable. When true, the engine
+     * sends the system prompt as a single-element content block array with
+     * `cache_control: { type: 'ephemeral' }` instead of a plain string. This
+     * lets Anthropic's prompt-cache layer serve hits across calls within the
+     * 5-minute ephemeral TTL.
+     *
+     * Default: false (system prompt is sent as a plain string — unchanged
+     * behavior).
+     */
+    cacheSystemPrompt?: boolean;
 }
 /**
  * Wrap a set of context files in `<file path="...">...</file>` XML tags,

package/dist/index.js

@@ -6627,11 +6627,18 @@ ${contextFilesBlock}` : "",
       let finalOutput = "";
       let totalInput = 0;
       let totalOutput = 0;
+      const systemField = config.cacheSystemPrompt ? [
+        {
+          type: "text",
+          text: systemPrompt,
+          cache_control: { type: "ephemeral" }
+        }
+      ] : systemPrompt;
       for (let i = 0; i < maxIterations; i++) {
         const createParams = {
           model: taskModel,
           max_tokens: 4096,
-          system: systemPrompt,
+          system: systemField,
           messages
         };
         if (toolDefs.length > 0) {

package/dist/provider-BHkqkSdq.d.ts

@@ -0,0 +1,89 @@
+/** LLM provider types — Story 1.5 / 2.1 */
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+interface ChatMessage {
+    role: "user" | "assistant" | "system";
+    content: string | ContentBlock[];
+}
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+} | {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: "document";
+    source: {
+        type: "base64";
+        media_type: "application/pdf";
+        data: string;
+    };
+};
+interface ChatParams {
+    messages: ChatMessage[];
+    system?: string;
+    tools?: ToolDefinition[];
+    maxTokens?: number;
+    temperature?: number;
+    model: string;
+    abortSignal?: AbortSignal;
+}
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
+interface ChatResult {
+    content: string;
+    toolUses?: ToolUse[];
+    usage: TokenUsage;
+    model: string;
+    stopReason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence";
+}
+interface ToolUse {
+    id: string;
+    name: string;
+    input: unknown;
+}
+interface ModelInfo {
+    id: string;
+    displayName: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    capabilities: Array<"chat" | "tools" | "vision" | "streaming">;
+    /** Cost in micro-cents per 1M tokens */
+    inputCostPerMToken?: number;
+    outputCostPerMToken?: number;
+}
+interface ResolvedModel {
+    provider: string;
+    model: string;
+}
+interface LLMProvider {
+    id: string;
+    displayName: string;
+    models: ModelInfo[];
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+    /** Convert ToolDefinition[] to provider-native format */
+    serializeTools(tools: ToolDefinition[]): unknown;
+}
+
+export type { ChatMessage as C, LLMProvider as L, ModelInfo as M, ResolvedModel as R, TokenUsage as T, ChatParams as a, ChatResult as b, ContentBlock as c, ToolUse as d, ToolDefinition as e };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botinabox",
-  "version": "2.10.1",
+  "version": "2.12.0",
   "description": "Bot in a Box — framework for building multi-agent bots",
   "type": "module",
   "main": "./dist/index.js",