@myagentroam/agent 0.9.125 → 0.9.127

package/dist/prompts/core.d.ts

@@ -14,5 +14,7 @@ export interface EnvironmentContextState {
     };
     guaranteedCommands?: Readonly<Record<string, string>>;
     workspace: string;
+    currentDate?: string;
+    timezone?: string;
 }
 export declare function buildEnvironmentContext(input: EnvironmentContextState, previous?: EnvironmentContextState, contextualEntries?: readonly string[]): string;

package/dist/prompts/core.js

@@ -18,6 +18,8 @@ export function buildEnvironmentContext(input, previous, contextualEntries = [])
             cwd: element('cwd', state.workspace),
             shell: state.shell ? element('shell', state.shell.name) : undefined,
             shell_path: state.shell ? element('shell_path', state.shell.path) : undefined,
+            current_date: state.currentDate ? element('current_date', state.currentDate) : undefined,
+            timezone: state.timezone ? element('timezone', state.timezone) : undefined,
             available_commands: commands.length
                 ? `<available_commands>${commands
                     .map(([name, version]) => `<available_command>${element('name', name)}${element('version', version)}</available_command>`)

package/dist/runtime/environment-context.d.ts

@@ -2,3 +2,4 @@ import type { ModelMessage } from '../model/contracts.js';
 import { type EnvironmentContextState } from '../prompts/core.js';
 export declare function restoreEnvironmentState(payload: unknown): EnvironmentContextState | undefined;
 export declare function environmentContextUpdate(current: EnvironmentContextState, previous?: EnvironmentContextState, contextualEntries?: readonly string[]): ModelMessage | undefined;
+export declare function currentLocalTimeContext(instant?: Date, timezone?: string): Pick<EnvironmentContextState, 'currentDate' | 'timezone'>;

package/dist/runtime/environment-context.js

@@ -5,6 +5,11 @@ const environmentStateSchema = z
     platform: z.string().min(1).max(64),
     architecture: z.string().min(1).max(64).optional(),
     workspace: z.string().max(32768),
+    currentDate: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/u)
+        .optional(),
+    timezone: z.string().min(1).max(128).optional(),
     shell: z
         .object({
         name: z.string().min(1).max(128),
@@ -27,15 +32,38 @@ export function restoreEnvironmentState(payload) {
     const parsed = environmentRecordSchema.safeParse(payload);
     if (!parsed.success)
         return undefined;
-    const { architecture, shell, guaranteedCommands, ...required } = parsed.data.state;
+    const { architecture, shell, guaranteedCommands, currentDate, timezone, ...required } = parsed.data.state;
     return {
         ...required,
         ...(architecture === undefined ? {} : { architecture }),
         ...(shell === undefined ? {} : { shell }),
-        ...(guaranteedCommands === undefined ? {} : { guaranteedCommands })
+        ...(guaranteedCommands === undefined ? {} : { guaranteedCommands }),
+        ...(currentDate === undefined ? {} : { currentDate }),
+        ...(timezone === undefined ? {} : { timezone })
     };
 }
 export function environmentContextUpdate(current, previous, contextualEntries = []) {
     const content = buildEnvironmentContext(current, previous, contextualEntries);
     return content ? { role: 'user', contextKind: 'environment', content } : undefined;
 }
+export function currentLocalTimeContext(instant = new Date(), timezone) {
+    try {
+        const zone = timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+        if (!zone)
+            throw new Error('Local timezone is unavailable.');
+        const parts = new Intl.DateTimeFormat('en-US', {
+            timeZone: zone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit'
+        }).formatToParts(instant);
+        const value = (kind) => parts.find((part) => part.type === kind)?.value;
+        return {
+            currentDate: `${value('year')}-${value('month')}-${value('day')}`,
+            timezone: zone
+        };
+    }
+    catch {
+        return { currentDate: instant.toISOString().slice(0, 10), timezone: 'Etc/UTC' };
+    }
+}

package/dist/sdk/agent.js

@@ -19,7 +19,7 @@ import { buildSystemPrompt, MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js
 import { buildEnvironmentContext } from '../prompts/core.js';
 import { modelOutputContinuationMessage } from '../prompts/output.js';
 import { retainedSessionResourcesSnapshot, retainedSessionResourcesUpdate } from '../prompts/resources.js';
-import { environmentContextUpdate, restoreEnvironmentState } from '../runtime/environment-context.js';
+import { currentLocalTimeContext, environmentContextUpdate, restoreEnvironmentState } from '../runtime/environment-context.js';
 import { executionBudgetEnvironmentEntry } from '../prompts/execution-budget.js';
 import { childSubagentInstruction } from '../prompts/subagent.js';
 import { sessionTitlePrompt } from '../prompts/title.js';
@@ -152,6 +152,10 @@ export async function createMarAgentWithAdapter(options) {
             if ([...active.keys()].some((key) => key.startsWith(`${sessionId}:`)))
                 throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Session already has an active execution.');
             const executionId = randomUUID(), turnId = internal.turnId ?? randomUUID(), queue = new AsyncQueue(), controller = new AbortController();
+            let executionEnvironment = {
+                ...currentEnvironment,
+                ...currentLocalTimeContext()
+            };
             const executionModels = models;
             const executionDefaultModelId = defaultModelId;
             const executionModelGeneration = modelGeneration;
@@ -287,6 +291,7 @@ export async function createMarAgentWithAdapter(options) {
                         includeImages: mode !== 'compact'
                     });
                     const messages = restored.messages;
+                    let recordedEnvironment = restored.environmentState;
                     let projectedExecutionBudgetStage;
                     const appendExecutionBudgetEnvironment = () => {
                         const currentStage = rolloutBudget?.active ? rolloutBudget.stage : 'inactive';
@@ -299,7 +304,7 @@ export async function createMarAgentWithAdapter(options) {
                             (currentStage === 'inactive' && previousStage === 'normal'))
                             return;
                         const entry = executionBudgetEnvironmentEntry(currentStage === 'normal' ? 'inactive' : currentStage);
-                        messages.push(environmentContextUpdate(currentEnvironment, currentEnvironment, [entry]));
+                        messages.push(environmentContextUpdate(executionEnvironment, executionEnvironment, [entry]));
                     };
                     const appendMailboxMessages = async () => {
                         let appended = false;
@@ -324,16 +329,17 @@ export async function createMarAgentWithAdapter(options) {
                         return appended;
                     };
                     const recordEnvironment = async () => {
-                        const message = environmentContextUpdate(currentEnvironment, restored.environmentState);
+                        const message = environmentContextUpdate(executionEnvironment, recordedEnvironment);
                         if (!message)
                             return;
                         await store.append(sessionId, {
                             type: 'context.environment',
-                            payload: { version: 1, state: currentEnvironment },
+                            payload: { version: 1, state: executionEnvironment },
                             executionId,
                             turnId
                         });
                         messages.push(message);
+                        recordedEnvironment = executionEnvironment;
                     };
                     let compactionUserMessages = [
                         ...restored.userMessages,
@@ -725,7 +731,7 @@ export async function createMarAgentWithAdapter(options) {
                             summary: compactSummary,
                             replacementHistory,
                             automatic: true,
-                            environment: currentEnvironment,
+                            environment: executionEnvironment,
                             modelId: selectedModel.id,
                             contextWindowTokens: selectedModel.contextWindowTokens,
                             ...(latestUsage === undefined ? {} : { usage: latestUsage }),
@@ -733,8 +739,9 @@ export async function createMarAgentWithAdapter(options) {
                             turnId
                         });
                         contextGc.reset();
-                        messages.splice(0, messages.length, environmentContextUpdate(currentEnvironment), ...compactedHistoryMessages(replacementHistory));
+                        messages.splice(0, messages.length, environmentContextUpdate(executionEnvironment), ...compactedHistoryMessages(replacementHistory));
                         projectedExecutionBudgetStage = undefined;
+                        recordedEnvironment = executionEnvironment;
                         compactionUserMessages = replacementHistory
                             .filter((message) => message.kind === 'user_input')
                             .map((message) => message.content);
@@ -780,6 +787,10 @@ export async function createMarAgentWithAdapter(options) {
                         let incompleteToolCall = false;
                         await ensureContextBudget();
                         appendExecutionBudgetEnvironment();
+                        if (mode !== 'compact') {
+                            executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
+                            await recordEnvironment();
+                        }
                         const toolsAllowed = mode !== 'compact' && (!rolloutBudget?.active || rolloutBudget.stage !== 'exhausted');
                         const roundTools = mode === 'compact' ? executionTools : toolsAllowed ? executionTools : [];
                         const systemPrompt = mode === 'compact'
@@ -1191,6 +1202,7 @@ export async function createMarAgentWithAdapter(options) {
                                 });
                                 messages.splice(0, messages.length, ...refreshed.messages);
                                 projectedExecutionBudgetStage = undefined;
+                                recordedEnvironment = refreshed.environmentState;
                                 compactionUserMessages = [...refreshed.userMessages];
                                 agentInstructionInsertIndex =
                                     refreshed.currentTurnUserIndex ?? Math.max(0, messages.length - 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.125",
+  "version": "0.9.127",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",