@andreprado/agentkit 0.1.0-alpha.14 → 0.1.0-alpha.15

package/README.md

@@ -48,6 +48,8 @@ agentkit conversations trace <conversation-id>
 
 Knowledge indexes local `.md`, `.txt`, and `.csv` sources into the capsule database and registers the internal `agentkit_search_knowledge` chat tool when `knowledge` is configured in `agentkit.config.ts`. `agentkit dev` and `agentkit chat` sync configured sources automatically; when embeddings are configured, local semantic search uses a libSQL vector sidecar. Hosted Cloudflare deploys package configured local Knowledge sources and sync them into the project Turso database automatically during `agentkit deploy`; when embeddings are configured, the deploy also creates and populates the hosted Turso vector index.
 
+Every chat run receives dynamic runtime date context: current ISO timestamp, local date, weekday, local date/time, and timezone. Set `timeZone` in `agentkit.config.ts` for scheduling agents so relative dates like "today" and "next Friday" resolve in the right business/user timezone.
+
 ## Deploy Later
 
 ```sh

package/docs/guides/run-evals.md

@@ -52,72 +52,120 @@ Do not edit `.agentkit/agentkit.db` by hand.
 Generated smoke eval:
 
 ```ts
-export default {
+import { defineEval } from "@andreprado/agentkit";
+
+export default defineEval({
   name: "smoke",
   input: "Say hello in one short sentence.",
   expect: {
-    contains: "hello",
+    response: {
+      caseInsensitiveContains: "hello",
+      maxLength: 160,
+    },
   },
-};
+});
 ```
 
 Supported assertion types:
 
 ```txt
-contains
-not_contains
-regex
-matches_regex
-persisted_tool_call
+response.contains
+response.containsAll
+response.containsAny
+response.caseInsensitiveContains
+response.notContains
+response.regex
+response.matchesRegex
+response.notRegex
+response.maxLength
+tools.called
+tools.calledOnce
+tools.count
+tools.order
+tools.persisted
+```
+
+Older flat aliases still work, including `contains`, `not_contains`, `regex`, `matches_regex`, and `persisted_tool_call`.
+
+For date-sensitive evals, set top-level `now` to an ISO timestamp with an explicit timezone designator such as `Z` or `-05:00`. AgentKit uses that fixed clock for every turn and tool call in the eval:
+
+```ts
+export default defineEval({
+  name: "appointment relative date",
+  now: "2026-02-04T02:30:00.000Z",
+  input: "What is today's date?",
+  expect: {
+    response: {
+      containsAll: ["2026-02-03", "Tuesday"],
+    },
+  },
+});
 ```
 
 Multi-turn conversation evals use `turns`:
 
 ```ts
-export default {
+import { defineEval } from "@andreprado/agentkit";
+
+export default defineEval({
   name: "buyer under budget",
   turns: [
     {
       input: "I want a house up to 600k near Pinheiros.",
       expect: {
-        persisted_tool_call: {
-          name: "buscar_imoveis",
-          status: "completed",
-          input: { maxPrice: 600000 },
+        tools: {
+          calledOnce: "buscar_imoveis",
+          persisted: {
+            name: "buscar_imoveis",
+            status: "completed",
+            input: { maxPrice: 600000 },
+          },
         },
       },
     },
     {
       input: "Show me the best two.",
       expect: {
-        contains: ["Pinheiros", "R$"],
+        response: {
+          containsAll: ["Pinheiros", "R$"],
+        },
       },
     },
   ],
-};
+});
 ```
 
-`persisted_tool_call` validates the tool call saved in local SQLite `tool_calls`, not a provider-specific raw response shape. It can be a tool name string or an object with `name`, `input`, `output`, `rendered`, `status`, and/or `visibility`.
+`tools.persisted` validates the tool call saved in local SQLite `tool_calls`, not a provider-specific raw response shape. It can be a tool name string or an object with `name`, `input`, `output`, `rendered`, `status`, and/or `visibility`.
+
+Use `tools.count` for the exact number of persisted calls in that turn, `tools.calledOnce` for exactly one call by name, and `tools.order` for required relative order. `tools.order` allows extra calls before, between, or after the named calls; pair it with `tools.count` when the exact call set matters.
 
 Use response assertions and persisted tool assertions together when internal operational output must not leak:
 
 ```ts
-export default {
+import { defineEval } from "@andreprado/agentkit";
+
+export default defineEval({
   name: "triage lead",
   input: '{"tool":"triage_real_estate_lead","input":{"email":"ada@example.com"}}',
   expect: {
-    not_contains: ["hot", "score"],
-    persisted_tool_call: {
-      name: "triage_real_estate_lead",
-      status: "completed",
-      visibility: "internal",
-      output: { status: "hot" },
+    response: {
+      notContains: ["hot", "score"],
+      notRegex: ["API_KEY|secret|token"],
+    },
+    tools: {
+      calledOnce: "triage_real_estate_lead",
+      persisted: {
+        name: "triage_real_estate_lead",
+        status: "completed",
+        visibility: "internal",
+        output: { status: "hot" },
+      },
     },
   },
-};
+});
 ```
 
-`tool_call` remains accepted as a backwards-compatible alias, but new evals should use `persisted_tool_call`.
+`tool_call` and `persisted_tool_call` remain accepted as backwards-compatible aliases, but new evals should use `tools.persisted`.
 
 Safe external-tool pattern:
 

package/docs/llms-full.txt

@@ -96,7 +96,7 @@ Prefer `env set --stdin` or `--from-env` for local secret values, and prefer `se
 Planned commands described by the contract but not implemented yet:
 
 ```sh
-agentkit eval create-from-conversation <conversation-id>
+agentkit eval from-conversation <conversation-id>
 ```
 
 ## Create And Test A Capsule
@@ -166,6 +166,7 @@ export default defineAgent({
     name: "test",
     model: "fake",
   },
+  timeZone: "America/New_York",
   instructions: "./prompts/instructions.md",
   secrets: [],
   tools: [],
@@ -178,6 +179,8 @@ export default defineAgent({
 });
 ```
 
+`timeZone` is optional and must be an IANA time zone when set. AgentKit injects dynamic runtime context into every chat run: current ISO timestamp, local date, local weekday, local date/time, and timezone. Use `timeZone` for scheduling, appointments, reminders, deadlines, and any prompt behavior that interprets "today", "tomorrow", weekdays, or relative dates. Do not hardcode today's date in `prompts/instructions.md`. If `timeZone` is omitted, AgentKit falls back to `AGENTKIT_TIME_ZONE`, then valid `TZ`, then the runtime default timezone.
+
 Valid runtime values:
 
 ```txt
@@ -473,6 +476,7 @@ Tool runtime rules:
 - tools that need SQL use canonical `ctx.db`; `ctx.database` and `ctx.storage.sql` are supported aliases;
 - tools can use `ctx.db.batch([...])` for atomic writes; local tools can also use `ctx.db.transaction(async (tx) => ...)`;
 - tools can inspect `ctx.runtime` with `{ environment, invocation, target, database }`;
+- tools can use `ctx.clock` for the same runtime clock injected into the agent prompt, including `now`, `isoTimestamp`, `timeZone`, `localDate`, `localWeekday`, and `localDateTime`;
 - tools must not import local database drivers or Node-only APIs. Use AgentKit runtime services instead.
 
 ## Database Tools And Dual Storage
@@ -717,14 +721,25 @@ npm run eval
 Supported assertion types:
 
 ```txt
-contains
-not_contains
-regex
-matches_regex
-persisted_tool_call
-```
-
-`persisted_tool_call` validates the tool call saved in local SQLite `tool_calls`, not a provider-specific raw response shape. It can be a tool name string or an object with `name`, `input`, `output`, `status`, and/or `visibility`. `tool_call` remains accepted as a backwards-compatible alias.
+response.contains
+response.containsAll
+response.containsAny
+response.caseInsensitiveContains
+response.notContains
+response.regex
+response.matchesRegex
+response.notRegex
+response.maxLength
+tools.called
+tools.calledOnce
+tools.count
+tools.order
+tools.persisted
+```
+
+Import `defineEval` from `@andreprado/agentkit` when writing new evals. `tools.persisted` validates the tool call saved in local SQLite `tool_calls`, not a provider-specific raw response shape. It can be a tool name string or an object with `name`, `input`, `output`, `rendered`, `status`, and/or `visibility`. `tool_call` and `persisted_tool_call` remain accepted as backwards-compatible aliases, but new evals should use `tools.persisted`.
+
+For date-sensitive evals, set top-level `now` to an ISO timestamp with an explicit timezone designator such as `Z` or `-05:00`. AgentKit uses that fixed clock for every turn and tool call in the eval so "today", "tomorrow", and weekdays remain deterministic while normal chat continues to use the real current date.
 
 Evals run the normal capsule tools. If a tool would write externally, delete, charge money, send email, or call a real customer system, make its `execute` implementation branch on `ctx.runtime.environment === "eval"` and return deterministic non-destructive output for eval runs. Do not invent an eval-only mock API; keep the behavior inside the registered tool contract unless AgentKit adds a first-class mock facility later.
 

package/docs/llms.txt

@@ -71,6 +71,8 @@ UI testing is part of the handoff. For local UI testing, run `agentkit dev`, ope
 
 `test/fake` is deterministic and validates scaffold, direct tool calls, and fake-provider evals. It does not validate natural conversation quality. Before claiming real conversation behavior has been tested, ask the owner which provider to use: OpenRouter, OpenAI, Anthropic, or another supported provider. Do not choose for them.
 
+AgentKit injects the current ISO timestamp, local date, weekday, local date/time, and timezone dynamically into every chat run. Set `timeZone` in `agentkit.config.ts` for scheduling agents so "today", "tomorrow", and weekdays resolve in the business/user timezone; otherwise AgentKit falls back to `AGENTKIT_TIME_ZONE`, valid `TZ`, then the runtime default. Do not hardcode today's date in prompts.
+
 Current local endpoints from `agentkit dev`:
 
 ```txt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andreprado/agentkit",
-  "version": "0.1.0-alpha.14",
+  "version": "0.1.0-alpha.15",
   "private": false,
   "type": "module",
   "repository": {

package/src/cli/cloud-client.ts

@@ -39,12 +39,24 @@ export type CloudLimitsResponse = {
   };
 };
 
+export type CloudProjectResolveResponse = {
+  project?: {
+    id?: string;
+    name?: string;
+    owner_state?: "anonymous" | "claimed";
+  };
+};
+
 export type DeployAccessTokenCreateResponse = {
   access_token?: {
     id?: string;
     deploy_id?: string;
+    account_id?: string;
     name?: string;
     token?: string;
+    created_at?: string;
+    expires_at?: string;
+    last_used_at?: string;
   };
 };
 
@@ -52,7 +64,11 @@ export type DeployAccessTokenListResponse = {
   access_tokens?: Array<{
     id?: string;
     deploy_id?: string;
+    account_id?: string;
     name?: string;
+    created_at?: string;
+    expires_at?: string;
+    last_used_at?: string;
   }>;
 };
 
@@ -94,6 +110,16 @@ export async function readCloudAuth(): Promise<CloudAuthConfig | null> {
   return null;
 }
 
+export async function readCloudAuthForApiUrl(apiUrl: string): Promise<CloudAuthConfig | null> {
+  const auth = await readCloudAuth();
+
+  if (auth?.source === "file" && !cloudAuthMatchesApiUrl(auth, apiUrl)) {
+    return null;
+  }
+
+  return auth;
+}
+
 export async function writeCloudAuth(config: CloudAuthConfig): Promise<void> {
   await mkdir(join(homedir(), ".agentkit"), { recursive: true });
   await writeFile(cloudAuthPath(), `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
@@ -156,11 +182,8 @@ export async function cloudPost<T>(apiUrl: string, path: string, body: unknown):
 
 export async function cloudFetch(apiUrl: string, path: string, init: RequestInit = {}): Promise<Response> {
   const headers = new Headers(init.headers);
-  const auth = await readCloudAuth();
-  const apiToken =
-    auth?.source === "file" && !cloudAuthMatchesApiUrl(auth, apiUrl)
-      ? undefined
-      : auth?.token;
+  const auth = await readCloudAuthForApiUrl(apiUrl);
+  const apiToken = auth?.token;
 
   if (apiToken && !headers.has("Authorization")) {
     headers.set("Authorization", `Bearer ${apiToken}`);
@@ -177,12 +200,9 @@ function cloudAuthMatchesApiUrl(auth: CloudAuthConfig, apiUrl: string): boolean
 }
 
 export async function cloudApiRequest(apiUrl: string, path: string, init: RequestInit): Promise<unknown> {
-  const auth = await readCloudAuth();
+  const auth = await readCloudAuthForApiUrl(apiUrl);
   const headers = new Headers(init.headers);
-  const apiToken =
-    auth?.source === "file" && !cloudAuthMatchesApiUrl(auth, apiUrl)
-      ? undefined
-      : auth?.token;
+  const apiToken = auth?.token;
 
   if (!headers.has("Content-Type") && init.body !== undefined) {
     headers.set("Content-Type", "application/json");

package/src/cli/deploy-readiness.ts

@@ -1,15 +1,15 @@
 import { findAgentCapsuleRoot, loadAgentCapsule } from "../runtime/config";
-import { readLocalDeployStateIfExists } from "../runtime/core/deploy-state";
-import { loadDeployReadinessContext, stableCloudProjectId, type DeployReadinessContext } from "../runtime/deploy-readiness";
+import { loadDeployReadinessContext, type DeployReadinessContext } from "../runtime/deploy-readiness";
 import { loadCapsuleEnv } from "../runtime/env";
 import { isAgentKitError } from "../runtime/errors";
 import {
   cloudApiRequest,
   formatCloudAuthSource,
-  readCloudAuth,
+  readCloudAuthForApiUrl,
   type CloudCapabilitiesResponse,
   type CloudLimitsResponse,
   type CloudMeResponse,
+  type CloudProjectResolveResponse,
   type CloudSecretsResponse,
 } from "./cloud-client";
 
@@ -34,7 +34,7 @@ export async function checkDeployReadiness(options: {
   requireLogin: boolean;
 }): Promise<DeployReadinessReport> {
   const context = await loadDeployReadinessContext(process.cwd(), process.env);
-  const auth = await readCloudAuth();
+  const auth = options.requireLogin ? await readCloudAuthForApiUrl(options.apiUrl) : null;
   const checks: DeployReadinessCheck[] = [];
   let cloudAuthUsable = false;
 
@@ -82,6 +82,19 @@ export async function checkDeployReadiness(options: {
     }
   }
 
+  if (cloudAuthUsable) {
+    try {
+      context.projectId = await resolveCloudProjectId(options.apiUrl, context.projectName);
+    } catch (error) {
+      checks.push({
+        status: "fail",
+        title: "Project identity",
+        message: `Could not resolve the account-scoped AgentKit Cloud project. ${formatReadinessError(error)}`,
+      });
+      cloudAuthUsable = false;
+    }
+  }
+
   if (cloudAuthUsable) {
     try {
       const payload = (await cloudApiRequest(options.apiUrl, "/v1/me/capabilities", {
@@ -315,16 +328,24 @@ export function formatReadinessError(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-export async function resolveProjectIdForSecretCommand(cwd: string): Promise<string> {
-  const state = await readLocalDeployStateIfExists(cwd);
+export async function resolveProjectIdForSecretCommand(cwd: string, apiUrl: string): Promise<string> {
+  const root = await findAgentCapsuleRoot(cwd);
+  const capsule = await loadAgentCapsule(root);
+  return resolveCloudProjectId(apiUrl, capsule.config.name);
+}
 
-  if (state?.project_id) {
-    return state.project_id;
+async function resolveCloudProjectId(apiUrl: string, projectName: string): Promise<string> {
+  const payload = (await cloudApiRequest(apiUrl, "/v1/projects/resolve", {
+    method: "POST",
+    body: JSON.stringify({ project_name: projectName }),
+  })) as CloudProjectResolveResponse;
+  const projectId = payload.project?.id;
+
+  if (!projectId) {
+    throw new Error("AgentKit Cloud did not return a project id.");
   }
 
-  const root = await findAgentCapsuleRoot(cwd);
-  const capsule = await loadAgentCapsule(root);
-  return stableCloudProjectId(capsule.config.name);
+  return projectId;
 }
 
 function secretSetCommand(secret: string, source: DeployReadinessContext["localSecrets"][string] | undefined): string {

package/src/cli/index.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 
 import { createProject } from "../create-project";
@@ -38,6 +38,7 @@ import {
   clearCloudAuth,
   cloudApiRequest,
   readCloudAuth,
+  readCloudAuthForApiUrl,
   readCloudError,
   resolveCloudApiUrl,
   verifyCloudLogin,
@@ -607,10 +608,10 @@ async function main() {
     }
 
     const apiUrl = await resolveCloudApiUrl(args.flags.api);
-    const auth = await readCloudAuth();
+    const auth = anonymous ? null : await readCloudAuthForApiUrl(apiUrl);
     const deploy = await deployBuildToAgentKitCloud(result, {
       apiUrl,
-      apiToken: auth?.token,
+      apiToken: anonymous ? null : auth?.token,
       anonymous: anonymous || !auth?.token,
     });
     const statePath = await writeLocalDeployState(result.root, deploy);
@@ -659,8 +660,8 @@ async function main() {
 
   if (args.command === "secret") {
     const [subcommand, name, ...valueParts] = args.positional;
-    const projectId = await resolveProjectIdForSecretCommand(process.cwd());
     const apiUrl = await resolveCloudApiUrl(args.flags.api);
+    const projectId = await resolveProjectIdForSecretCommand(process.cwd(), apiUrl);
 
     if (subcommand === "list") {
       const payload = await cloudApiRequest(apiUrl, `/v1/projects/${encodeURIComponent(projectId)}/secrets`, {
@@ -949,9 +950,12 @@ async function ensureDeployChatAccessToken(options: {
         `/v1/deploys/${encodeURIComponent(options.deployId)}/access-tokens`,
         { method: "GET" },
       )) as DeployAccessTokenListResponse;
-      const stillExists = (listed.access_tokens ?? []).some((token) => token.id === existing.id);
+      const stillUsable = (listed.access_tokens ?? []).some(
+        (token) => token.id === existing.id && deployAccessTokenMetadataIsUsable(token),
+      );
 
-      if (stillExists) {
+      if (stillUsable) {
+        await chmod(path, 0o600);
         return { status: "ready", path, tokenId: existing.id, created: false };
       }
     }
@@ -977,6 +981,15 @@ async function ensureDeployChatAccessToken(options: {
   }
 }
 
+function deployAccessTokenMetadataIsUsable(token: { expires_at?: string }): boolean {
+  if (!token.expires_at) {
+    return true;
+  }
+
+  const expiresAtMs = Date.parse(token.expires_at);
+  return Number.isFinite(expiresAtMs) && expiresAtMs > Date.now();
+}
+
 async function readDeployAccessTokenFile(path: string): Promise<{ id?: string; deploy_id?: string } | null> {
   try {
     const parsed = JSON.parse(await readFile(path, "utf8")) as DeployAccessTokenCreateResponse;
@@ -989,6 +1002,7 @@ async function readDeployAccessTokenFile(path: string): Promise<{ id?: string; d
 async function writeSecretJson(path: string, value: unknown): Promise<void> {
   await mkdir(dirname(path), { recursive: true });
   await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+  await chmod(path, 0o600);
 }
 
 async function requireLocalDeployState(): Promise<LocalDeployState> {

package/src/cloud/client.ts

@@ -1,4 +1,4 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { chmod, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
 import type { AgentBuildResult } from "../runtime/targets/cloudflare/build";
@@ -15,7 +15,7 @@ export async function deployBuildToAgentKitCloud(
   const headers = new Headers({
     "Content-Type": "application/json",
   });
-  const apiToken = options.apiToken ?? process.env.AGENTKIT_CLOUD_API_TOKEN;
+  const apiToken = options.anonymous ? undefined : options.apiToken ?? process.env.AGENTKIT_CLOUD_API_TOKEN;
 
   if (apiToken) {
     headers.set("Authorization", `Bearer ${apiToken}`);
@@ -70,7 +70,8 @@ export async function writeLocalDeployState(root: string, deploy: CreateDeployRe
   };
 
   await mkdir(join(root, ".agentkit"), { recursive: true });
-  await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
+  await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+  await chmod(statePath, 0o600);
   return statePath;
 }
 

package/src/cloud/contracts.ts

@@ -58,6 +58,6 @@ export type CreateDeployResponse = {
 
 export type AgentKitCloudDeployOptions = {
   apiUrl: string;
-  apiToken?: string;
+  apiToken?: string | null;
   anonymous?: boolean;
 };

package/src/create-project.ts

@@ -114,7 +114,7 @@ async function resolveAgentKitDependency(): Promise<string> {
 
   const packageRoot = resolve(moduleDir, "..");
 
-  if (await directoryExists(resolve(packageRoot, "../..", ".git"))) {
+  if (await pathExists(resolve(packageRoot, "../..", ".git"))) {
     return `file:${packageRoot}`;
   }
 

package/src/index.ts

@@ -210,6 +210,7 @@ export type ToolRenderResult = {
 export type ToolRenderContext<Input = unknown> = {
   input: Input;
   runtime: ToolRuntimeContext;
+  clock: ToolClockContext;
 };
 
 export type ToolRuntimeContext = {
@@ -219,10 +220,20 @@ export type ToolRuntimeContext = {
   database: "sqlite" | "turso" | "none";
 };
 
+export type ToolClockContext = {
+  now: Date;
+  isoTimestamp: string;
+  timeZone: string;
+  localDate: string;
+  localWeekday: string;
+  localDateTime: string;
+};
+
 export type ToolContext = {
   secrets: Record<string, string>;
   signal: AbortSignal;
   runtime: ToolRuntimeContext;
+  clock: ToolClockContext;
   database: DatabaseRunner;
   db: DatabaseRunner;
   storage: {
@@ -254,6 +265,7 @@ export type AgentConfig = {
   name: string;
   runtime: AgentRuntime;
   provider: AgentProvider;
+  timeZone?: string;
   instructions: string;
   secrets: string[];
   tools?: AgentTool[];
@@ -379,7 +391,18 @@ function validatePositiveInteger(value: number, field: string): void {
 export { loadAgentCapsule, findAgentCapsuleRoot } from "./runtime/config";
 export { runAgentMessage, runAgentMessageFromCwd } from "./runtime/chat";
 export { listConversationsFromCwd, getConversationFromCwd } from "./runtime/conversations";
-export { runEvalsFromCwd } from "./runtime/evals";
+export { defineEval, runEvalsFromCwd } from "./runtime/evals";
+export type {
+  EvalCase,
+  EvalExpect,
+  EvalResponseExpectation,
+  EvalRunSummary,
+  EvalResult,
+  EvalToolsContainerExpectation,
+  EvalToolsExpectation,
+  EvalTurn,
+  ToolExpectation,
+} from "./runtime/evals";
 export { getConversationTraceFromCwd } from "./runtime/traces";
 export { runToolFromCwd } from "./runtime/tool-runner";
 export { startAgentDevServer } from "./runtime/dev-server";

package/src/providers/pi.ts

@@ -97,7 +97,7 @@ async function runPiProvider(input: ProviderRunInput): Promise<ProviderRunResult
         content: [
           {
             type: "text",
-            text: result.rendered?.text ?? JSON.stringify(result.output),
+            text: providerToolResultText(result),
           },
         ],
         isError: false,
@@ -109,6 +109,19 @@ async function runPiProvider(input: ProviderRunInput): Promise<ProviderRunResult
   throw new AgentKitError("runtime_error", `Pi provider exceeded ${MAX_TOOL_TURNS} tool turns.`);
 }
 
+export function providerToolResultText(result: {
+  name: string;
+  visibility?: "user" | "internal";
+  rendered?: { text?: string };
+  output: unknown;
+}): string {
+  if (result.visibility === "internal") {
+    return `Internal tool ${result.name} completed.`;
+  }
+
+  return result.rendered?.text ?? JSON.stringify(result.output);
+}
+
 async function runPiTurn(
   model: Model<any>,
   context: Parameters<typeof stream>[1],

package/src/providers/test.ts

@@ -37,6 +37,17 @@ export const testProviderAdapter: ProviderAdapter = {
       };
     }
 
+    const currentDate = answerCurrentDate(input.instructions, userMessage.content);
+
+    if (currentDate) {
+      return {
+        message: {
+          role: "assistant",
+          content: currentDate,
+        },
+      };
+    }
+
     const rememberedName = answerRememberedName(input.messages);
 
     if (rememberedName) {
@@ -95,6 +106,31 @@ function answerRememberedName(messages: AgentMessage[]): string | null {
   return null;
 }
 
+function answerCurrentDate(instructions: string, content: string): string | null {
+  if (!/(today|current date|what date|data de hoje|hoje)/i.test(content)) {
+    return null;
+  }
+
+  const localDate = readRuntimeContextValue(instructions, "Local date");
+
+  if (!localDate) {
+    return null;
+  }
+
+  const localWeekday = readRuntimeContextValue(instructions, "Local weekday");
+  const timeZone = readRuntimeContextValue(instructions, "Time zone");
+  const weekday = localWeekday ? ` (${localWeekday})` : "";
+  const zone = timeZone ? ` in ${timeZone}` : "";
+
+  return `Today is ${localDate}${weekday}${zone}.`;
+}
+
+function readRuntimeContextValue(instructions: string, label: string): string | null {
+  const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = instructions.match(new RegExp(`^- ${escapedLabel}: (.+)$`, "m"));
+  return match?.[1]?.trim() || null;
+}
+
 function asksForName(content: string): boolean {
   return /what(?:'s| is) my name\??/i.test(content) || /(como|qual)\s+(é|e)\s*(o\s+)?meu nome\??/i.test(content);
 }