zilmate 1.0.0 → 1.1.0

package/.env.example

@@ -4,6 +4,20 @@ ZILMATE_USER_ID=
 TAVILY_API_KEY=
 UPSTASH_REDIS_REST_URL=
 UPSTASH_REDIS_REST_TOKEN=
+ZILMATE_JOBS_ENABLED=false
+UPSTASH_QSTASH_TOKEN=
+ZILMATE_PUBLIC_JOB_WEBHOOK_URL=
+ZILMATE_JOB_WEBHOOK_SECRET=
+ZILMATE_TRIGGER_WORKFLOWS_ENABLED=false
+DEEPGRAM_API_KEY=
+ZILMATE_VOICE_ENABLED=false
+ZILMATE_VOICE_MODE=agent
+ZILMATE_VOICE_LISTEN_MODEL=flux-general-en
+ZILMATE_VOICE_LISTEN_VERSION=v2
+ZILMATE_VOICE_TTS_MODEL=aura-2-thalia-en
+ZILMATE_VOICE_LANGUAGE=en
+ZILMATE_VOICE_LANGUAGE_HINTS=
+ZILMATE_VOICE_BARGE_IN=true
 ZILO_MANAGER_MODEL=minimax/minimax-m3
 ZILO_HELP_MODEL=alibaba/qwen3.7-plus
 ZILO_POST_MODEL=alibaba/qwen3.7-plus

package/README.md

@@ -16,6 +16,15 @@ zilmate setup
 zilmate --help
 ```
 
+Running `zilmate` with no arguments opens the status dashboard and then the guided launcher menu. If the AI Gateway key is missing, the launcher offers setup before starting chat.
+
+When a new CLI/SDK release is published, users can update without remembering npm commands:
+
+```powershell
+zilmate update
+zilmate version
+```
+
 ### GitHub/private install
 
 Before npm publishing, install directly from the GitHub repo:
@@ -37,8 +46,8 @@ iwr https://raw.githubusercontent.com/zester4/zilo-manager/main/install.ps1 | ie
 The installer runs the full first-use flow:
 
 1. Installs ZilMate globally.
-2. Runs `zilmate setup` to collect `AI_GATEWAY_API_KEY`, optional `COMPOSIO_API_KEY`, optional `TAVILY_API_KEY`, and optional Redis keys.
-3. Lets users skip Composio, Tavily, and Redis keys.
+2. Runs `zilmate setup` to collect `AI_GATEWAY_API_KEY`.
+3. Lets users skip optional Composio, Tavily, Redis, background jobs, QStash, and trigger workflows.
 4. Runs `zilmate ping` to verify the key.
 5. Starts `zilmate talk`.
 
@@ -78,7 +87,42 @@ The easiest path is:
 zilmate setup
 ```
 
-It asks for `AI_GATEWAY_API_KEY`, optionally asks for `COMPOSIO_API_KEY`, `TAVILY_API_KEY`, and Upstash Redis keys, then writes a local `.env`. Composio, Tavily, and Redis can be skipped.
+Before asking for secrets, setup shows what to have ready:
+
+- Required: AI Gateway key.
+- Optional app tools: Composio key.
+- Optional web research: Tavily key.
+- Optional cloud memory/jobs: Upstash Redis URL and token.
+- Optional hosted schedules: QStash token and public webhook URL.
+- Optional realtime voice: Deepgram key.
+
+Then it asks for `AI_GATEWAY_API_KEY` and guides users through optional features:
+
+- Composio external app tools.
+- Tavily web research.
+- Upstash Redis memory/job storage.
+- Local background jobs and schedules.
+- Upstash QStash hosted schedules.
+- Composio trigger-to-job workflows.
+- Deepgram realtime voice mode.
+
+Every optional feature can be skipped. If users only want chat, they only need the AI Gateway key.
+
+Voice can be managed without opening `.env`:
+
+```powershell
+zilmate voice setup
+zilmate voice enable
+zilmate voice disable
+zilmate voice doctor
+```
+
+Inside `zilmate talk`, use `/voice` to switch the current chat session into voice-style mode and `/voice -q` to stop it:
+
+```text
+/voice
+/voice -q
+```
 
 You can also create `.env` manually:
 
@@ -89,6 +133,20 @@ ZILMATE_USER_ID=zilmate-generated-local-user-id
 TAVILY_API_KEY=your_tavily_key
 UPSTASH_REDIS_REST_URL=
 UPSTASH_REDIS_REST_TOKEN=
+ZILMATE_JOBS_ENABLED=false
+UPSTASH_QSTASH_TOKEN=
+ZILMATE_PUBLIC_JOB_WEBHOOK_URL=
+ZILMATE_JOB_WEBHOOK_SECRET=
+ZILMATE_TRIGGER_WORKFLOWS_ENABLED=false
+DEEPGRAM_API_KEY=
+ZILMATE_VOICE_ENABLED=false
+ZILMATE_VOICE_MODE=agent
+ZILMATE_VOICE_LISTEN_MODEL=flux-general-en
+ZILMATE_VOICE_LISTEN_VERSION=v2
+ZILMATE_VOICE_TTS_MODEL=aura-2-thalia-en
+ZILMATE_VOICE_LANGUAGE=en
+ZILMATE_VOICE_LANGUAGE_HINTS=
+ZILMATE_VOICE_BARGE_IN=true
 ZILO_MANAGER_MODEL=minimax/minimax-m3
 ZILO_HELP_MODEL=alibaba/qwen3.7-plus
 ZILO_POST_MODEL=alibaba/qwen3.7-plus
@@ -102,6 +160,21 @@ Composio is optional. If `COMPOSIO_API_KEY` is set, ZilMate creates a stable loc
 
 Redis is optional. If `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` are set, chat turns, scratchpads, and Composio session ids use Redis. If they are missing, ZilMate falls back to local files under `.zilo-manager/`.
 
+Background jobs are optional. Setup explains the difference between local jobs and hosted schedules. Local jobs and local schedules run while `zilmate jobs worker` is running. They do not keep running after a laptop sleeps, shuts down, or loses internet. For hosted schedules that can fire while the local machine is closed, configure QStash plus a public job webhook URL.
+
+Realtime voice is optional. If `DEEPGRAM_API_KEY` and `ZILMATE_VOICE_ENABLED=true` are set, ZilMate can open Deepgram Voice Agent sessions. The default listen model is `flux-general-en` with `v2` because Flux is designed for low-latency voice agents and model-integrated end-of-turn detection. The default spoken voice is `aura-2-thalia-en`. Browser voice should use platform echo cancellation through `getUserMedia`; terminal microphone capture needs a local audio adapter.
+
+Use `zilmate voice setup` for a focused voice-only wizard. Use `zilmate voice enable` and `zilmate voice disable` to toggle voice later without editing config files.
+
+For unattended setup or installers, pass the options directly:
+
+```powershell
+zilmate setup --yes --ai-gateway-key <key> --jobs-enabled true
+zilmate setup --yes --ai-gateway-key <key> --composio-key <key> --trigger-workflows-enabled true
+zilmate setup --yes --ai-gateway-key <key> --qstash-token <token> --job-webhook-url https://example.com/api/zilmate/jobs
+zilmate setup --yes --ai-gateway-key <key> --voice-enabled true --deepgram-key <key>
+```
+
 ## Development Commands
 
 Use these while working inside the project folder:
@@ -117,6 +190,14 @@ npm run zilmate -- apps status
 npm run zilmate -- triggers listen
 npm run zilmate -- triggers types github
 npm run zilmate -- triggers list
+npm run zilmate -- jobs create "Research today's priority updates and summarize them"
+npm run zilmate -- jobs list
+npm run zilmate -- jobs worker --once
+npm run zilmate -- voice doctor
+npm run zilmate -- voice setup
+npm run zilmate -- voice disable
+npm run zilmate -- voice enable
+npm run zilmate -- voice turn "What should I focus on today?"
 npm run zilmate -- remember "Prefers concise support replies"
 npm run zilmate -- recall support
 npm run zilmate -- memory list
@@ -152,6 +233,8 @@ Then use ZilMate directly:
 zilmate --help
 zilmate setup
 zilmate doctor
+zilmate update
+zilmate version
 zilmate env check
 zilmate config
 zilmate talk
@@ -163,6 +246,21 @@ zilmate triggers types github
 zilmate triggers create GITHUB_BRANCH_CREATED_TRIGGER --dry-run --owner zester4 --repo zilo-manager
 zilmate triggers create GITHUB_COMMIT_EVENT --owner zester4 --repo zilo-manager
 zilmate triggers list
+zilmate jobs create "Research today's priority updates and summarize them"
+zilmate jobs create "Prepare my weekday morning briefing" --schedule "daily"
+zilmate jobs list
+zilmate jobs status job_xxx
+zilmate jobs logs job_xxx
+zilmate jobs run job_xxx
+zilmate jobs worker
+zilmate jobs cancel job_xxx
+zilmate voice doctor
+zilmate voice config
+zilmate voice setup
+zilmate voice disable
+zilmate voice enable
+zilmate voice turn "Plan my next two hours"
+zilmate voice agent-probe
 zilmate remember "Use a warm but concise support tone"
 zilmate recall support
 zilmate memory list
@@ -213,6 +311,8 @@ Available SDK methods:
 - `research({ query | message })`: local docs and web research.
 - `image({ prompt, provider, size, outputDir })`: image generation.
 - `remember({ text, tags })`, `recall({ query, limit })`, `listMemories()`, `forget(id)`, `clearMemories()`: durable memory helpers.
+- `createJob({ task, schedule, source, metadata })`, `listJobs({ status, limit })`, `getJob(id)`, `getJobLogs(id)`, `runJob(id)`, `runDueJobs()`, `handleJobWebhook({ jobId, secret }, expectedSecret)`, `cancelJob(id)`: background job and hosted webhook helpers.
+- `getVoiceConfig()`, `startVoiceSession({ audio, onEvent, sessionId })`: Deepgram realtime voice configuration and Agent API session helpers.
 
 For UI integrations, pass `onProgress` to render agent/tool progress and `confirm` to approve or block external write-like Composio actions.
 
@@ -233,6 +333,13 @@ For UI integrations, pass `onProgress` to render agent/tool progress and `confir
 - `triggers info <trigger>`: show trigger config and payload schemas.
 - `triggers create <trigger> --flag value`: create a trigger instance; unknown flags become trigger config.
 - `triggers list`: list trigger instances.
+- `jobs create "<task>"`: queue a background job, optionally with `--schedule "daily"` or `--schedule "every 15 minutes"`.
+- `jobs list`: list queued/running/completed jobs.
+- `jobs status <id>`: inspect one job.
+- `jobs logs <id>`: inspect job progress, output, and errors.
+- `jobs run <id>`: run a queued job immediately.
+- `jobs worker`: run the local job processor and local scheduler.
+- `jobs cancel <id>`: cancel one job.
 - `help`: fast troubleshooting and app guidance.
 - `chat`: one-shot natural dialogue about ZiloShift workflows.
 - `post`: WhatsApp/status/social copy generation.
@@ -251,8 +358,12 @@ ZilMate uses a manager agent that delegates to focused subagents and external to
 - Post: launch messages, WhatsApp statuses, captions, and outreach copy.
 - Research: local Zilo docs first, then external docs/web research when needed.
 - Image: image generation through Gateway image models.
+- Automation Planner: background jobs, schedules, trigger workflows, QStash/webhook planning, monitoring, and follow-up automations.
+- Personal Assistant: daily planning, reminders, briefings, prioritization, follow-ups, summaries, and memory-aware organization.
+- Developer Helper: CLI/SDK usage, Next.js integration, publishing, QStash, Cloudflare tunnels, webhooks, Composio setup, and debugging.
 - Composio: external app discovery, auth links, schemas, and execution, attached only to the manager.
 - Memory: durable ZilMate facts and preferences saved locally or in Redis, available through CLI commands and manager tools.
+- Jobs: background task creation, schedule setup, status checks, logs, and cancellation available through CLI, SDK, and manager tools.
 
 Local ZiloShift docs live under `src/doc/`. ZilMate reads them on demand through dedicated tools instead of dumping all docs into every prompt. The manager prefers these local docs for ZiloShift support, worker, venue, payment, verification, SMS, and dispute questions.
 
@@ -287,7 +398,7 @@ zilmate triggers listen --trigger ti_abc123
 zilmate triggers listen --trigger-slug GMAIL_NEW_EMAIL_EVENT --once
 ```
 
-This is terminal-local. For persistent public callbacks, use webhook/tunnel support later.
+This is terminal-local. When `ZILMATE_TRIGGER_WORKFLOWS_ENABLED=true`, trigger events handled by `zilmate triggers listen` also create background jobs. ZilMate includes generic workflow prompts for Gmail, GitHub, Slack, and calendar-style events, and falls back to a general external-app summary task for other toolkits.
 
 The manager agent also has trigger tools. In `zilmate talk`, you can ask:
 
@@ -299,6 +410,37 @@ create that trigger
 
 ZilMate should discover current trigger slugs first, inspect the trigger schema, prefer a dry-run payload, and ask for confirmation before creating a real trigger.
 
+## Background Jobs And Schedules
+
+Use jobs when ZilMate should keep working after a chat turn ends:
+
+```powershell
+zilmate jobs create "Research AI assistant scheduling patterns and save a summary"
+zilmate jobs create "Prepare my morning briefing" --schedule daily
+zilmate jobs worker
+```
+
+Local job storage uses `.zilo-manager/jobs.json` and `.zilo-manager/job-logs.json` unless Redis is configured. With Redis, jobs and logs use the same Upstash REST connection as memory.
+
+Schedules supported locally include `hourly`, `daily`, `every 15 minutes`, `every 2 hours`, `every 1 day`, and ISO date/time strings. QStash schedules can use `cron:<expression>` when `UPSTASH_QSTASH_TOKEN` and `ZILMATE_PUBLIC_JOB_WEBHOOK_URL` are configured.
+
+Hosted apps can expose a webhook route and call:
+
+```ts
+import { createZilMate } from 'zilmate/server';
+
+export async function POST(req: Request) {
+  const body = await req.json();
+  const zilmate = createZilMate();
+  const result = await zilmate.handleJobWebhook(
+    { jobId: body.jobId, secret: req.headers.get('ZilMate-Webhook-Secret') ?? undefined },
+    process.env.ZILMATE_JOB_WEBHOOK_SECRET,
+  );
+
+  return Response.json(result);
+}
+```
+
 ## Model Notes
 
 - Manager/orchestration default: `minimax/minimax-m3`.

package/dist/agents/automation-planner.agent.d.ts

@@ -0,0 +1,103 @@
+import { ToolLoopAgent } from 'ai';
+export declare function createAutomationPlannerAgent(): ToolLoopAgent<never, {
+    appKnowledge: import("ai").Tool<{
+        key: "agent-docs" | "readme";
+    }, string>;
+    listTriggerTypes: import("ai").Tool<{
+        toolkit?: string | undefined;
+        limit?: number | undefined;
+    }, {
+        items: {
+            slug: string;
+            name: string;
+            description: string;
+            toolkit: {
+                slug: string;
+                name: string;
+                logo: string;
+            };
+            payload: Record<string, unknown>;
+            config: Record<string, unknown>;
+            version?: string | undefined;
+            instructions?: string | undefined;
+        }[];
+        totalPages: number;
+        nextCursor?: string | null | undefined;
+    }>;
+    showTriggerType: import("ai").Tool<{
+        triggerSlug: string;
+    }, {
+        slug: string;
+        name: string;
+        description: string;
+        toolkit: {
+            slug: string;
+            name: string;
+            logo: string;
+        };
+        payload: Record<string, unknown>;
+        config: Record<string, unknown>;
+        version?: string | undefined;
+        instructions?: string | undefined;
+    }>;
+    listTriggers: import("ai").Tool<{
+        limit?: number | undefined;
+        showDisabled?: boolean | undefined;
+    }, {
+        items: {
+            connectedAccountId: string;
+            id: string;
+            updatedAt: string;
+            disabledAt: string | null;
+            state: Record<string, unknown>;
+            triggerConfig: Record<string, unknown>;
+            triggerName: string;
+            uuid?: string | undefined;
+            triggerData?: string | undefined;
+        }[];
+        nextCursor: string | null;
+        totalPages: number;
+    }>;
+    createTrigger: import("ai").Tool<{
+        triggerSlug: string;
+        triggerConfig?: Record<string, unknown> | undefined;
+        connectedAccountId?: string | undefined;
+        dryRun?: boolean | undefined;
+    }, {
+        triggerId: string;
+    } | {
+        triggerConfig?: Record<string, unknown>;
+        connectedAccountId?: string;
+        userId: string;
+        triggerSlug: string;
+        dryRun: boolean;
+    }>;
+    createJob: import("ai").Tool<{
+        task: string;
+        schedule?: string | undefined;
+        runAt?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, import("../server.js").ZilMateJob>;
+    listJobs: import("ai").Tool<{
+        status?: "running" | "failed" | "queued" | "succeeded" | "cancelled" | undefined;
+        limit?: number | undefined;
+    }, import("../server.js").ZilMateJob[]>;
+    showJob: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").ZilMateJob | null>;
+    listJobLogs: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").JobLog[]>;
+    cancelJob: import("ai").Tool<{
+        id: string;
+    }, import("../server.js").ZilMateJob | null>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
+}, never>;
+//# sourceMappingURL=automation-planner.agent.d.ts.map

package/dist/agents/automation-planner.agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automation-planner.agent.d.ts","sourceRoot":"","sources":["../../src/agents/automation-planner.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAQhD,wBAAgB,4BAA4B;;;;;;;;;;;;;;;;;;;mBAoBw7zG,CAAC;wBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAz2S,CAAC;uBAAqC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UADzshG"}

package/dist/agents/automation-planner.agent.js

@@ -0,0 +1,28 @@
+import { stepCountIs, ToolLoopAgent } from 'ai';
+import { models } from '../config/models.js';
+import { appKnowledgeTool } from '../tools/app-knowledge.tool.js';
+import { jobTools } from '../tools/jobs.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { triggerTools } from '../tools/triggers.tool.js';
+import { limits } from '../safety/limits.js';
+export function createAutomationPlannerAgent() {
+    return new ToolLoopAgent({
+        model: models.manager,
+        instructions: [
+            'You are ZilMate Automation Planner. Design practical automations, schedules, background jobs, trigger workflows, and follow-up flows.',
+            'Use time tools for current date/time and schedule-relative wording.',
+            'Use job tools to inspect existing jobs and logs. Create or cancel jobs only when the user clearly asks and approval is available through the manager.',
+            'Use trigger tools to discover Composio trigger types, inspect schemas, and reason about trigger setup. Prefer dry-run thinking before real creation.',
+            'Explain local worker limits clearly: local jobs need `zilmate jobs worker`; laptop-closed automation needs QStash plus a public job webhook.',
+            'Return concise plans with exact commands or setup steps when useful.',
+        ].join(' '),
+        tools: {
+            ...timeTools,
+            ...jobTools,
+            ...triggerTools,
+            appKnowledge: appKnowledgeTool,
+        },
+        stopWhen: stepCountIs(limits.subagentSteps),
+    });
+}
+//# sourceMappingURL=automation-planner.agent.js.map

package/dist/agents/automation-planner.agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"automation-planner.agent.js","sourceRoot":"","sources":["../../src/agents/automation-planner.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,4BAA4B;IAC1C,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,OAAO;QACrB,YAAY,EAAE;YACZ,uIAAuI;YACvI,qEAAqE;YACrE,uJAAuJ;YACvJ,sJAAsJ;YACtJ,8IAA8I;YAC9I,sEAAsE;SACvE,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,GAAG,QAAQ;YACX,GAAG,YAAY;YACf,YAAY,EAAE,gBAAgB;SAC/B;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/chat.agent.d.ts

@@ -3,6 +3,14 @@ export declare function createChatAgent(): ToolLoopAgent<never, {
     appKnowledge: import("ai").Tool<{
         key: "agent-docs" | "readme";
     }, string>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
     listZiloDocs: import("ai").Tool<Record<string, never>, {
         key: string;
         title: string;

package/dist/agents/chat.agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat.agent.d.ts","sourceRoot":"","sources":["../../src/agents/chat.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAKhD,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;UAU9B"}
+{"version":3,"file":"chat.agent.d.ts","sourceRoot":"","sources":["../../src/agents/chat.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAOhD,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAW9B"}

package/dist/agents/chat.agent.js

@@ -2,15 +2,18 @@ import { stepCountIs, ToolLoopAgent } from 'ai';
 import { models } from '../config/models.js';
 import { appKnowledgeTool } from '../tools/app-knowledge.tool.js';
 import { ziloDocsTools } from '../tools/zilo-docs.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { limits } from '../safety/limits.js';
 export function createChatAgent() {
     return new ToolLoopAgent({
         model: models.chat,
-        instructions: 'You are the ZiloShift conversational app guide. Explain workflows for workers, venues, admin operations, payments, disputes, shifts, onboarding, and launch tasks in a calm practical tone. Use local ZiloShift docs on demand for accurate product behavior instead of guessing. Keep answers practical and do not dump long docs into the response.',
+        instructions: 'You are the ZiloShift conversational app guide. Explain workflows for workers, venues, admin operations, payments, disputes, shifts, onboarding, and launch tasks in a calm practical tone. Use local ZiloShift docs on demand for accurate product behavior instead of guessing. Use getCurrentTime when the user asks for current date/time or relative schedule wording. Keep answers practical and do not dump long docs into the response.',
         tools: {
             ...ziloDocsTools,
+            ...timeTools,
             appKnowledge: appKnowledgeTool,
         },
-        stopWhen: stepCountIs(6),
+        stopWhen: stepCountIs(limits.subagentSteps),
     });
 }
 //# sourceMappingURL=chat.agent.js.map

package/dist/agents/chat.agent.js.map

@@ -1 +1 @@
-{"version":3,"file":"chat.agent.js","sourceRoot":"","sources":["../../src/agents/chat.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,MAAM,UAAU,eAAe;IAC7B,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,IAAI;QAClB,YAAY,EAAE,uVAAuV;QACrW,KAAK,EAAE;YACL,GAAG,aAAa;YAChB,YAAY,EAAE,gBAAgB;SAC/B;QACD,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC;KACzB,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"chat.agent.js","sourceRoot":"","sources":["../../src/agents/chat.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,eAAe;IAC7B,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,IAAI;QAClB,YAAY,EAAE,ibAAib;QAC/b,KAAK,EAAE;YACL,GAAG,aAAa;YAChB,GAAG,SAAS;YACZ,YAAY,EAAE,gBAAgB;SAC/B;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/developer-helper.agent.d.ts

@@ -0,0 +1,94 @@
+import { ToolLoopAgent } from 'ai';
+export declare function createDeveloperHelperAgent(runId?: string): ToolLoopAgent<never, {
+    readScratchpad: import("ai").Tool<Record<string, never>, string>;
+    appendScratchpad: import("ai").Tool<{
+        note: string;
+    }, string>;
+    docsSearch: import("ai").Tool<{
+        query: string;
+    }, import("../tools/web-search.tool.js").WebSearchResult[]>;
+    docsFetch: import("ai").Tool<{
+        url: string;
+    }, string>;
+    webSearch: import("ai").Tool<{
+        query: string;
+        maxResults?: number | undefined;
+        searchDepth?: "basic" | "advanced" | undefined;
+        includeAnswer?: boolean | undefined;
+        includeRawContent?: "text" | "markdown" | undefined;
+        includeDomains?: string[] | undefined;
+        excludeDomains?: string[] | undefined;
+        topic?: "general" | "news" | "finance" | undefined;
+        timeRange?: "day" | "week" | "month" | "year" | undefined;
+    }, {
+        answer: string | undefined;
+        results: {
+            title: string;
+            url: string;
+            content: string;
+            rawContent: string | undefined;
+            score: number | undefined;
+            publishedDate: string | undefined;
+        }[];
+    }>;
+    webExtract: import("ai").Tool<{
+        urls: string[];
+        query?: string | undefined;
+        extractDepth?: "basic" | "advanced" | undefined;
+        format?: "text" | "markdown" | undefined;
+        chunksPerSource?: number | undefined;
+    }, {
+        results: {
+            url: string;
+            title: string;
+            rawContent: string;
+        }[];
+        failedResults: {
+            url: string;
+            error: string;
+        }[];
+    }>;
+    webMap: import("ai").Tool<{
+        url: string;
+        instructions?: string | undefined;
+        maxDepth?: number | undefined;
+        limit?: number | undefined;
+        allowExternal?: boolean | undefined;
+    }, {
+        baseUrl: string;
+        results: string[];
+    }>;
+    deepResearch: import("ai").Tool<{
+        input: string;
+        model?: "mini" | "pro" | undefined;
+        timeoutSeconds?: number | undefined;
+        pollIntervalSeconds?: number | undefined;
+    }, {
+        requestId: string;
+        status: string;
+        content: string;
+        sources: {
+            title: string;
+            url: string;
+        }[];
+        message?: never;
+    } | {
+        requestId: string;
+        status: string;
+        message: string;
+        content?: never;
+        sources?: never;
+    }>;
+    appKnowledge: import("ai").Tool<{
+        key: "agent-docs" | "readme";
+    }, string>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
+}, never>;
+//# sourceMappingURL=developer-helper.agent.d.ts.map

package/dist/agents/developer-helper.agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"developer-helper.agent.d.ts","sourceRoot":"","sources":["../../src/agents/developer-helper.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAUhD,wBAAgB,0BAA0B,CAAC,KAAK,SAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAuB3D"}

package/dist/agents/developer-helper.agent.js

@@ -0,0 +1,34 @@
+import { stepCountIs, ToolLoopAgent } from 'ai';
+import { models } from '../config/models.js';
+import { appKnowledgeTool } from '../tools/app-knowledge.tool.js';
+import { docsFetchTool } from '../tools/docs-fetch.tool.js';
+import { docsSearchTool } from '../tools/docs-search.tool.js';
+import { createScratchpadTools } from '../tools/scratchpad.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { deepResearchTool, webExtractTool, webMapTool, webSearchTool } from '../tools/web-search.tool.js';
+import { limits } from '../safety/limits.js';
+export function createDeveloperHelperAgent(runId = 'default') {
+    const scratchpadTools = createScratchpadTools(runId);
+    return new ToolLoopAgent({
+        model: models.research,
+        instructions: [
+            'You are ZilMate Developer Helper. Help developers integrate ZilMate through the CLI, SDK, Next.js server routes, background jobs, QStash webhooks, Cloudflare tunnels, Composio, package publishing, and troubleshooting.',
+            'Prefer local app/package knowledge first. For external technical facts, prefer official docs and primary sources.',
+            'Use time tools for current versions, release timing, date-sensitive debugging, or schedule-relative wording.',
+            'Return exact commands, minimal code snippets, and clear verification steps. Do not invent credentials or claim external setup succeeded without tool evidence.',
+        ].join(' '),
+        tools: {
+            ...timeTools,
+            docsSearch: docsSearchTool,
+            docsFetch: docsFetchTool,
+            webSearch: webSearchTool,
+            webExtract: webExtractTool,
+            webMap: webMapTool,
+            deepResearch: deepResearchTool,
+            appKnowledge: appKnowledgeTool,
+            ...scratchpadTools,
+        },
+        stopWhen: stepCountIs(limits.subagentSteps),
+    });
+}
+//# sourceMappingURL=developer-helper.agent.js.map

package/dist/agents/developer-helper.agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"developer-helper.agent.js","sourceRoot":"","sources":["../../src/agents/developer-helper.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC1G,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,0BAA0B,CAAC,KAAK,GAAG,SAAS;IAC1D,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,QAAQ;QACtB,YAAY,EAAE;YACZ,2NAA2N;YAC3N,mHAAmH;YACnH,8GAA8G;YAC9G,gKAAgK;SACjK,CAAC,IAAI,CAAC,GAAG,CAAC;QACX,KAAK,EAAE;YACL,GAAG,SAAS;YACZ,UAAU,EAAE,cAAc;YAC1B,SAAS,EAAE,aAAa;YACxB,SAAS,EAAE,aAAa;YACxB,UAAU,EAAE,cAAc;YAC1B,MAAM,EAAE,UAAU;YAClB,YAAY,EAAE,gBAAgB;YAC9B,YAAY,EAAE,gBAAgB;YAC9B,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/docs-research.agent.d.ts

@@ -100,6 +100,14 @@ export declare function createDocsResearchAgent(runId?: string): ToolLoopAgent<n
     appKnowledge: import("ai").Tool<{
         key: "agent-docs" | "readme";
     }, string>;
+    getCurrentTime: import("ai").Tool<{
+        timeZone?: string | undefined;
+    }, {
+        iso: string;
+        unixMs: number;
+        timeZone: string;
+        formatted: string;
+    }>;
     listZiloDocs: import("ai").Tool<Record<string, never>, {
         key: string;
         title: string;

package/dist/agents/docs-research.agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docs-research.agent.d.ts","sourceRoot":"","sources":["../../src/agents/docs-research.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAShD,wBAAgB,uBAAuB,CAAC,KAAK,SAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmBxD"}
+{"version":3,"file":"docs-research.agent.d.ts","sourceRoot":"","sources":["../../src/agents/docs-research.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAWhD,wBAAgB,uBAAuB,CAAC,KAAK,SAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoBxD"}

package/dist/agents/docs-research.agent.js

@@ -6,13 +6,16 @@ import { appKnowledgeTool } from '../tools/app-knowledge.tool.js';
 import { createScratchpadTools } from '../tools/scratchpad.tool.js';
 import { ziloDocsTools } from '../tools/zilo-docs.tool.js';
 import { deepResearchTool, webCrawlTool, webExtractTool, webMapTool, webSearchTool } from '../tools/web-search.tool.js';
+import { timeTools } from '../tools/time.tool.js';
+import { limits } from '../safety/limits.js';
 export function createDocsResearchAgent(runId = 'default') {
     const scratchpadTools = createScratchpadTools(runId);
     return new ToolLoopAgent({
         model: models.research,
-        instructions: 'You are a focused docs research subagent. For ZiloShift product behavior, search/read local Zilo docs first. For external facts, prefer official or primary docs: search lightly, extract known URLs deeply, map before crawling, crawl only small docs sections, and use deepResearch only for broad synthesis where the user clearly benefits from a heavier task. Return compact answers with source URLs. Use the scratchpad for compact intermediate notes only when research spans multiple sources.',
+        instructions: 'You are a focused docs research subagent. For ZiloShift product behavior, search/read local Zilo docs first. For external facts, prefer official or primary docs: search lightly, extract known URLs deeply, map before crawling, crawl only small docs sections, and use deepResearch only for broad synthesis where the user clearly benefits from a heavier task. Use getCurrentTime for current date/time or relative-date research framing. Return compact answers with source URLs. Use the scratchpad for compact intermediate notes only when research spans multiple sources.',
         tools: {
             ...ziloDocsTools,
+            ...timeTools,
             docsSearch: docsSearchTool,
             docsFetch: docsFetchTool,
             webSearch: webSearchTool,
@@ -23,7 +26,7 @@ export function createDocsResearchAgent(runId = 'default') {
             appKnowledge: appKnowledgeTool,
             ...scratchpadTools,
         },
-        stopWhen: stepCountIs(8),
+        stopWhen: stepCountIs(limits.subagentSteps),
     });
 }
 //# sourceMappingURL=docs-research.agent.js.map

package/dist/agents/docs-research.agent.js.map

@@ -1 +1 @@
-{"version":3,"file":"docs-research.agent.js","sourceRoot":"","sources":["../../src/agents/docs-research.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAExH,MAAM,UAAU,uBAAuB,CAAC,KAAK,GAAG,SAAS;IACvD,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,QAAQ;QACtB,YAAY,EAAE,4eAA4e;QAC1f,KAAK,EAAE;YACL,GAAG,aAAa;YAChB,UAAU,EAAE,cAAc;YAC1B,SAAS,EAAE,aAAa;YACxB,SAAS,EAAE,aAAa;YACxB,UAAU,EAAE,cAAc;YAC1B,MAAM,EAAE,UAAU;YAClB,QAAQ,EAAE,YAAY;YACtB,YAAY,EAAE,gBAAgB;YAC9B,YAAY,EAAE,gBAAgB;YAC9B,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC;KACzB,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"docs-research.agent.js","sourceRoot":"","sources":["../../src/agents/docs-research.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACxH,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,MAAM,UAAU,uBAAuB,CAAC,KAAK,GAAG,SAAS;IACvD,MAAM,eAAe,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrD,OAAO,IAAI,aAAa,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC,QAAQ;QACtB,YAAY,EAAE,wjBAAwjB;QACtkB,KAAK,EAAE;YACL,GAAG,aAAa;YAChB,GAAG,SAAS;YACZ,UAAU,EAAE,cAAc;YAC1B,SAAS,EAAE,aAAa;YACxB,SAAS,EAAE,aAAa;YACxB,UAAU,EAAE,cAAc;YAC1B,MAAM,EAAE,UAAU;YAClB,QAAQ,EAAE,YAAY;YACtB,YAAY,EAAE,gBAAgB;YAC9B,YAAY,EAAE,gBAAgB;YAC9B,GAAG,eAAe;SACnB;QACD,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,aAAa,CAAC;KAC5C,CAAC,CAAC;AACL,CAAC"}

package/dist/agents/image.agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image.agent.d.ts","sourceRoot":"","sources":["../../src/agents/image.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAIhD,wBAAgB,gBAAgB;;;;;;UAO/B"}
+{"version":3,"file":"image.agent.d.ts","sourceRoot":"","sources":["../../src/agents/image.agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,IAAI,CAAC;AAKhD,wBAAgB,gBAAgB;;;;;;UAO/B"}