@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/printModelStatus.d.ts

@@ -0,0 +1,63 @@
+import type { SDKAssistantMessageError } from '@sema-agent/agent-types';
+import { type RetryStatus, type RetryStatusArmLike, type RetryStatusNotice } from './retryStatus.js';
+export declare const PRINT_MODEL_STATUS_SUBTYPE = "_sema_model_status";
+export declare const PRINT_LAST_MODEL_STATUS_KEY = "_sema_last_model_status";
+export interface PrintModelStatusCtx {
+    readonly sessionId: string;
+    readonly nowMs: number;
+    readonly mintUuid: () => string;
+    readonly model?: string;
+}
+export interface PrintModelStatusPayload {
+    readonly kind: RetryStatus['kind'];
+    readonly terminal?: true;
+    readonly attempt?: number;
+    readonly max_retries?: number;
+    readonly retry_delay_ms?: number;
+    readonly error_status?: number;
+    readonly provider_condition?: string;
+    readonly err_class?: string;
+    readonly elapsed_ms?: number;
+    readonly timeout_ms?: number;
+    readonly model?: string;
+    readonly phase: RetryStatusNotice['phase'];
+    readonly recourse?: NonNullable<RetryStatusNotice['recourse']>;
+    readonly message: string;
+}
+export interface PrintApiRetryFrame {
+    readonly type: 'system';
+    readonly subtype: 'api_retry';
+    readonly attempt: number;
+    readonly max_retries: number;
+    readonly retry_delay_ms: number;
+    readonly error_status: number | null;
+    readonly error: SDKAssistantMessageError;
+    readonly _sema_provider_condition?: string;
+    readonly _sema_model?: string;
+    readonly _sema_message: string;
+    readonly uuid: string;
+    readonly session_id: string;
+}
+export interface PrintModelStatusSupersetFrame {
+    readonly type: 'system';
+    readonly subtype: typeof PRINT_MODEL_STATUS_SUBTYPE;
+    readonly _sema_model_status: PrintModelStatusPayload & {
+        readonly refresh?: true;
+    };
+    readonly uuid: string;
+    readonly session_id: string;
+}
+export type PrintModelStatusFrame = PrintApiRetryFrame | PrintModelStatusSupersetFrame;
+export interface PrintModelStatusResultFields {
+    readonly _sema_last_model_status?: PrintModelStatusPayload;
+}
+export interface PrintLaneArmLike extends RetryStatusArmLike {
+    readonly type?: string;
+    readonly event?: RetryStatusArmLike;
+}
+export interface PrintModelStatusTracker {
+    take(msg: PrintLaneArmLike | null | undefined, ctx: PrintModelStatusCtx): PrintModelStatusFrame | null;
+    beginTurn(): void;
+    resultFields(nowMs: number): PrintModelStatusResultFields;
+}
+export declare function createPrintModelStatusTracker(): PrintModelStatusTracker;

package/dist/printModelStatus.js

@@ -0,0 +1,155 @@
+import { retryStatusFromArm, retryStatusNotice } from './retryStatus.js';
+import { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+export const PRINT_MODEL_STATUS_SUBTYPE = '_sema_model_status';
+export const PRINT_LAST_MODEL_STATUS_KEY = '_sema_last_model_status';
+function httpStatusOf(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v > 0 && v <= 999 ? v : undefined;
+}
+function ccRetryErrorCategory(status) {
+    const code = httpStatusOf(status.errorStatus);
+    if (code === 529 || status.providerCondition === 'overloaded')
+        return 'overloaded';
+    if (code === 429)
+        return 'rate_limit';
+    if (code === 401 || code === 403)
+        return 'authentication_failed';
+    if (code !== undefined && code >= 408)
+        return 'server_error';
+    return 'unknown';
+}
+function modelStatusPayload(status, ctx) {
+    const code = httpStatusOf(status.errorStatus);
+    const terminal = 'terminal' in status && status.terminal === true;
+    const sane = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined);
+    const count = (v) => (typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : undefined);
+    const retryDelayMs = status.kind !== 'waiting' && !terminal ? sane(Math.max(0, status.deadline - ctx.nowMs)) : undefined;
+    const attempt = count(status.attempt);
+    const maxRetries = count(status.maxRetries);
+    const elapsed = sane(status.elapsedMs);
+    const ceiling = sane(status.timeoutMs);
+    const model = ctx.model !== undefined && ctx.model.length > 0 ? ctx.model : undefined;
+    const notice = retryStatusNotice(status, model !== undefined ? { modelName: model } : undefined);
+    return {
+        kind: status.kind,
+        ...(terminal ? { terminal: true } : {}),
+        ...(attempt !== undefined ? { attempt } : {}),
+        ...(maxRetries !== undefined ? { max_retries: maxRetries } : {}),
+        ...(retryDelayMs !== undefined ? { retry_delay_ms: retryDelayMs } : {}),
+        ...(code !== undefined ? { error_status: code } : {}),
+        ...(typeof status.providerCondition === 'string' ? { provider_condition: status.providerCondition } : {}),
+        ...(typeof status.errClass === 'string' ? { err_class: status.errClass } : {}),
+        ...(elapsed !== undefined ? { elapsed_ms: elapsed } : {}),
+        ...(ceiling !== undefined ? { timeout_ms: ceiling } : {}),
+        ...(model !== undefined ? { model } : {}),
+        phase: notice.phase,
+        ...(notice.recourse !== undefined ? { recourse: notice.recourse } : {}),
+        message: notice.line,
+    };
+}
+function apiRetryKeyOf(status) {
+    const terminal = 'terminal' in status && status.terminal === true;
+    const ok = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0;
+    if (status.kind === 'waiting' || terminal || !ok(status.attempt) || !ok(status.maxRetries))
+        return null;
+    return `${String(status.attempt)}/${String(status.maxRetries)}/${String(status.errClass ?? '')}/${String(status.errorStatus ?? '')}`;
+}
+function statusFrameOf(status, ctx, uuid, refresh) {
+    const payload = modelStatusPayload(status, ctx);
+    if (apiRetryKeyOf(status) !== null && !refresh) {
+        return {
+            type: 'system',
+            subtype: 'api_retry',
+            attempt: status.attempt ?? 0,
+            max_retries: status.maxRetries ?? 0,
+            retry_delay_ms: payload.retry_delay_ms ?? 0,
+            error_status: payload.error_status ?? null,
+            error: ccRetryErrorCategory(status),
+            ...(payload.provider_condition !== undefined ? { _sema_provider_condition: payload.provider_condition } : {}),
+            ...(payload.model !== undefined ? { _sema_model: payload.model } : {}),
+            _sema_message: payload.message,
+            uuid,
+            session_id: ctx.sessionId,
+        };
+    }
+    return { type: 'system', subtype: PRINT_MODEL_STATUS_SUBTYPE, _sema_model_status: { ...payload, ...(refresh ? { refresh: true } : {}) }, uuid, session_id: ctx.sessionId };
+}
+function isMainLaneArm(msg) {
+    const tri = (o, key) => {
+        try {
+            const d = Object.getOwnPropertyDescriptor(o, key);
+            if (d !== undefined && !('value' in d))
+                return { ok: false };
+            return { ok: true, v: readOwnDataValue(o, key) };
+        }
+        catch {
+            return { ok: false };
+        }
+    };
+    const top = tri(msg, 'parentToolCallId');
+    if (!top.ok)
+        return false;
+    const event = tri(msg, 'event');
+    if (!event.ok)
+        return false;
+    const nested = typeof event.v === 'object' && event.v !== null ? tri(event.v, 'parentToolCallId') : { ok: true, v: undefined };
+    if (!nested.ok)
+        return false;
+    return typeof top.v !== 'string' && typeof nested.v !== 'string';
+}
+export function createPrintModelStatusTracker() {
+    let last = null;
+    let lastApiRetryKey = null;
+    const clear = () => {
+        last = null;
+        lastApiRetryKey = null;
+    };
+    return {
+        take(msg, ctx) {
+            try {
+                const type = guardedRead(() => readOwnDataValue(msg, 'type'));
+                if (type === 'stream_event' || type === 'tool_end_result') {
+                    if (msg !== null && msg !== undefined && isMainLaneArm(msg))
+                        clear();
+                    return null;
+                }
+                if (type !== 'retry_status')
+                    return null;
+                const sessionId = readOwnDataNonEmptyString(ctx, 'sessionId');
+                const mintUuid = readOwnDataValue(ctx, 'mintUuid');
+                const nowMs = readOwnDataFiniteNumber(ctx, 'nowMs');
+                if (sessionId === undefined || typeof mintUuid !== 'function' || nowMs === undefined)
+                    return null;
+                const status = retryStatusFromArm(msg, nowMs);
+                if (status === undefined)
+                    return null;
+                if (status === null) {
+                    clear();
+                    return null;
+                }
+                const model = readOwnDataNonEmptyString(ctx, 'model');
+                const key = apiRetryKeyOf(status);
+                const refresh = key !== null && key === lastApiRetryKey;
+                const safeCtx = { sessionId, nowMs, mintUuid, ...(model !== undefined ? { model } : {}) };
+                const frame = statusFrameOf(status, safeCtx, mintUuid(), refresh);
+                lastApiRetryKey = key;
+                last = { status, model };
+                return frame;
+            }
+            catch {
+                return null;
+            }
+        },
+        beginTurn: clear,
+        resultFields(nowMs) {
+            try {
+                if (last === null)
+                    return {};
+                const now = typeof nowMs === 'number' && Number.isFinite(nowMs) ? nowMs : 0;
+                return { _sema_last_model_status: modelStatusPayload(last.status, { ...(last.model !== undefined ? { model: last.model } : {}), nowMs: now }) };
+            }
+            catch {
+                return {};
+            }
+        },
+    };
+}

package/dist/request/taskRequest.d.ts

@@ -1,6 +1,7 @@
-import type { TaskRequest } from '@sema-agent/sdk';
+import type { TaskRequest, UserAttachment } from '@sema-agent/sdk';
 import { type OutputStyleSeatReading } from '../outputStyleSeatCapability.js';
 import { type ApprovalReachWord } from '../approvalReachWire.js';
+import { type HostSettingNotice, type HostTurnSettings, type HostTurnSettingsInput } from '../hostTurnSettings.js';
 export type RequestLane = 'interactive' | 'print' | 'utility';
 export type TaskRequestLike = Record<string, unknown>;
 export interface RequestFieldSpec {
@@ -22,7 +23,9 @@ export interface TaskRequestInput {
     reasoningEffort?: string;
     model?: string;
     images?: readonly unknown[];
+    userAttachments?: readonly UserAttachment[];
     skills?: unknown;
+    userInvokedSkills?: readonly string[];
     mcpServers?: unknown;
     clientContext?: Record<string, unknown>;
     scratchpadDir?: string;
@@ -51,19 +54,14 @@ export interface TaskRequestInput {
     fallbackModel?: string;
     maxThinkingTokens?: number;
     memoryCapture?: 'off';
-    memory?: 'off';
-    fileHistory?: TaskRequest['fileHistory'];
     inheritEnv?: InheritEnvWord;
     requireExistingSession?: TaskRequest['requireExistingSession'];
     disableSkills?: TaskRequest['disableSkills'];
     rewind?: Record<string, unknown>;
     repo?: string;
+    hostSettings: HostTurnSettings;
     settings?: {
-        resolved?: Record<string, unknown>;
-        webSearch?: Record<string, unknown>;
         ultracode?: boolean;
-        hooks?: Record<string, unknown>;
-        outputStyle?: string;
     };
 }
 export declare const TASK_REQUEST_OMISSION_CAUSES: readonly ["upstream_absent", "other_channel", "off_lane", "not_live"];
@@ -78,6 +76,7 @@ export declare function taskRequestOmissionCauseNotice(cause: unknown): string;
 export interface TaskRequestAssembly {
     readonly request: TaskRequestLike;
     readonly omitted: readonly TaskRequestOmission[];
+    readonly host: HostTurnSettings;
 }
 export type TaskRequestSeatReading = {
     readonly seat: 'seated';
@@ -95,14 +94,21 @@ export interface UpstreamAbsentRequestIntent {
 export declare const UPSTREAM_ABSENT_REQUEST_INTENTS: readonly UpstreamAbsentRequestIntent[];
 export declare const REQUEST_LANES: readonly RequestLane[];
 export declare function taskRequestSeatOf(key: string, lane: RequestLane): TaskRequestSeatReading;
+export declare function hostTurnSettings(input: HostTurnSettingsInput): HostTurnSettings;
+export type HostSettingsRefilterResult = {
+    readonly kind: 'send';
+    readonly request: TaskRequestLike;
+    readonly hooksDropped: number;
+} | {
+    readonly kind: 'refuse';
+    readonly notice: HostSettingNotice;
+};
+export declare function refilterHostSettings(request: TaskRequestLike, fresh: HostTurnSettings, lane: RequestLane): HostSettingsRefilterResult;
 export declare const MEMORY_CAPTURE_OFF: "off";
 export declare function memoryCaptureDeclarationField(declared: boolean): {
     memoryCapture: 'off';
 } | Record<string, never>;
 export declare const MEMORY_OFF: "off";
-export declare function memoryOffDeclarationField(declared: boolean): {
-    memory: 'off';
-} | Record<string, never>;
 export declare const FILE_HISTORY_DISABLED: "disabled";
 export declare const INHERIT_ENV_WORDS: readonly ["all", "scrub"];
 export type InheritEnvWord = (typeof INHERIT_ENV_WORDS)[number];