humanish 0.111.4 → 0.113.0

package/dist/actors/computer-use/openai-requests.d.ts

@@ -1,62 +0,0 @@
-import type { CuaTurnRequest } from "./loop.js";
-import type { ReasoningEffort } from "../reasoning-effort.js";
-import type { ActorConversation } from "../contract.js";
-import { CarriedConversation } from "./openai-context.js";
-import { type OpenAiReasoningSummary, type ParsedOpenAiResponse } from "./openai-wire.js";
-/** Request settings fixed for a provider's whole session. */
-export interface OpenAiRequestSettings {
-    readonly model: string;
-    readonly reasoningEffort: ReasoningEffort;
-    readonly maxOutputTokens?: number;
-    readonly safetyIdentifier?: string;
-}
-/** The conversation as the provider has it after its last accepted reply. */
-export interface OpenAiConversationState {
-    lastResponseId: string | undefined;
-    /** computer_call ids the next request owes an output for. */
-    pendingCallIds: string[];
-    /** Accepted replies so far; the next request is number `replies + 1`. */
-    replies: number;
-    /** The whole conversation, which explicit-context requests carry within its token budget. */
-    conversation: CarriedConversation;
-    /** explicit_context after a zero-data-retention rejection or when configured. */
-    mode: "previous_response_id" | "explicit_context";
-    /** Undefined once the account or model rejected reasoning summaries. */
-    reasoningSummary: OpenAiReasoningSummary | undefined;
-}
-/**
- * The items the next request adds to the conversation: the opening message with the first
- * screen, or an output for each pending computer_call with the latest screenshot and any hint.
- * Built once per turn, so every attempt at the request and the accepted reply see the same items.
- */
-export declare function turnInputItems(state: OpenAiConversationState, req: CuaTurnRequest): readonly unknown[];
-/**
- * The body of the next participant request: the opening request, or a continuation carrying
- * `sent` (turnInputItems). A threaded continuation names the previous response; an
- * explicit-context one carries the conversation ahead of `sent`.
- */
-export declare function turnRequestBody(settings: OpenAiRequestSettings, state: OpenAiConversationState, req: CuaTurnRequest, sent: readonly unknown[]): Record<string, unknown>;
-/** The body of the read-only closing report: no tools, a small output limit, a strict schema. */
-export declare function debriefRequestBody(settings: OpenAiRequestSettings, state: OpenAiConversationState, req: CuaTurnRequest, sent: readonly unknown[]): Record<string, unknown>;
-/**
- * Move the conversation on to an accepted reply to a request that added `sent`. A participant
- * reply cut off by the output limit is set aside, so the next request is the same one again
- * (outputLimitRetry); its actions never run, so no call output is owed for them.
- */
-export declare function acceptReply(state: OpenAiConversationState, parsed: ParsedOpenAiResponse, closing: boolean, sent: readonly unknown[]): void;
-/** The trace's account of how a session carried its conversation (ActorConversation). */
-export declare class ConversationRecord {
-    private readonly now;
-    private explicitReason;
-    private rejection;
-    private switchedAt;
-    private switchedAtRequest;
-    private summarizedTurns;
-    private readonly requests;
-    constructor(configured: boolean, now: () => number);
-    /** The organization rejected server-side state, so the request being sent is explicit_context. */
-    switched(rejection: NonNullable<ActorConversation["rejection"]>): void;
-    /** A participant request just went out with `sent` after the carried conversation. */
-    requested(state: OpenAiConversationState, sent: readonly unknown[]): void;
-    snapshot(state: OpenAiConversationState): ActorConversation;
-}

package/dist/actors/computer-use/openai-requests.js

@@ -1,144 +0,0 @@
-import { CarriedConversation, estimateTokens } from "./openai-context.js";
-import { buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, openingMessage, } from "./openai-wire.js";
-/** The closing report's output limit: its own cap, or the declared limit when that is lower. */
-const CLOSING_OUTPUT_LIMIT = 1024;
-function requestContext(settings, state, instructions) {
-    return {
-        stateless: state.mode === "explicit_context",
-        model: settings.model,
-        instructions,
-        reasoningEffort: settings.reasoningEffort,
-        ...(settings.maxOutputTokens === undefined
-            ? {}
-            : { maxOutputTokens: settings.maxOutputTokens }),
-        ...(state.reasoningSummary === undefined ? {} : { reasoningSummary: state.reasoningSummary }),
-        ...(settings.safetyIdentifier === undefined
-            ? {}
-            : { safetyIdentifier: settings.safetyIdentifier }),
-    };
-}
-/** No reply has been accepted yet, so the next request opens the conversation. */
-function isFirstTurn(state) {
-    return state.replies === 0;
-}
-/**
- * The items the next request adds to the conversation: the opening message with the first
- * screen, or an output for each pending computer_call with the latest screenshot and any hint.
- * Built once per turn, so every attempt at the request and the accepted reply see the same items.
- */
-export function turnInputItems(state, req) {
-    if (isFirstTurn(state))
-        return [openingMessage(req.instructions, req.observation.screenshot)];
-    return [
-        ...state.pendingCallIds.map((id) => buildCallOutput(id, req.observation.screenshot, req.acknowledgedSafetyChecks)),
-        ...hintItems(req.contextHint),
-    ];
-}
-/**
- * The body of the next participant request: the opening request, or a continuation carrying
- * `sent` (turnInputItems). A threaded continuation names the previous response; an
- * explicit-context one carries the conversation ahead of `sent`.
- */
-export function turnRequestBody(settings, state, req, sent) {
-    const ctx = requestContext(settings, state, req.instructions);
-    if (isFirstTurn(state))
-        return buildInitialRequest(ctx, req.observation.screenshot);
-    return buildContinuationRequest({
-        ctx,
-        previousResponseId: state.lastResponseId,
-        callOutputs: [...sent],
-        ...(state.mode === "explicit_context"
-            ? { explicitContextItems: state.conversation.carried() }
-            : {}),
-    });
-}
-/** The body of the read-only closing report: no tools, a small output limit, a strict schema. */
-export function debriefRequestBody(settings, state, req, sent) {
-    return {
-        ...turnRequestBody(settings, state, req, sent),
-        tool_choice: "none",
-        max_output_tokens: Math.min(settings.maxOutputTokens ?? CLOSING_OUTPUT_LIMIT, CLOSING_OUTPUT_LIMIT),
-        text: {
-            format: {
-                type: "json_schema",
-                name: "participant_closing_report",
-                strict: true,
-                schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["summary", "frictionReports"],
-                    properties: {
-                        summary: { type: "string" },
-                        frictionReports: { type: "array", items: { type: "string" } },
-                    },
-                },
-            },
-        },
-    };
-}
-/**
- * Move the conversation on to an accepted reply to a request that added `sent`. A participant
- * reply cut off by the output limit is set aside, so the next request is the same one again
- * (outputLimitRetry); its actions never run, so no call output is owed for them.
- */
-export function acceptReply(state, parsed, closing, sent) {
-    if (!closing && parsed.turn.interruption === "output_limit")
-        return;
-    if (parsed.turn.responseId !== undefined)
-        state.lastResponseId = parsed.turn.responseId;
-    state.pendingCallIds = parsed.callIds;
-    state.replies += 1;
-    state.conversation.accept(state.replies, sent, parsed.outputItems);
-}
-/** The trace's account of how a session carried its conversation (ActorConversation). */
-export class ConversationRecord {
-    now;
-    explicitReason;
-    rejection;
-    switchedAt;
-    switchedAtRequest;
-    summarizedTurns = 0;
-    requests = [];
-    constructor(configured, now) {
-        this.now = now;
-        if (configured)
-            this.explicitReason = "configured";
-    }
-    /** The organization rejected server-side state, so the request being sent is explicit_context. */
-    switched(rejection) {
-        this.explicitReason = "zdr_rejection";
-        this.rejection = rejection;
-        this.switchedAt = new Date(this.now()).toISOString();
-        // Counted like requests[], which includes replies set aside at their output limit.
-        this.switchedAtRequest = this.requests.length + 1;
-    }
-    /** A participant request just went out with `sent` after the carried conversation. */
-    requested(state, sent) {
-        if (state.mode !== "explicit_context") {
-            this.requests.push({ mode: "threaded" });
-            return;
-        }
-        const carried = state.conversation.size();
-        // Only summaries a request carried count; the conversation also trims after the last reply.
-        this.summarizedTurns = carried.notedTurns;
-        this.requests.push({
-            mode: "explicit_context",
-            carriedExchanges: carried.exchanges,
-            carriedScreenshots: carried.screenshots,
-            estimatedInputTokens: carried.estimatedTokens + estimateTokens(sent),
-        });
-    }
-    snapshot(state) {
-        return {
-            mode: state.mode === "explicit_context" ? "explicit_context" : "threaded",
-            ...(this.explicitReason === undefined ? {} : { explicitReason: this.explicitReason }),
-            ...(this.rejection === undefined ? {} : { rejection: this.rejection }),
-            ...(this.switchedAt === undefined ? {} : { switchedAt: this.switchedAt }),
-            ...(this.switchedAtRequest === undefined
-                ? {}
-                : { switchedAtRequest: this.switchedAtRequest }),
-            summarizedTurns: this.summarizedTurns,
-            requests: this.requests.map((request) => ({ ...request })),
-        };
-    }
-}