@xiaozhiclaw/qlogicagent-core 0.6.1 → 0.6.3

package/dist/types/embedded/cloud-agent.d.ts

@@ -89,6 +89,9 @@ export interface CloudAgentOptions extends Omit<CreateEmbeddedAgentOptions, "too
     onWait?(invocation: CloudToolInvocation, wait: CloudToolWait["wait"]): Promise<void>;
     /** Await the durable attempt record before network I/O and before acknowledging completion. */
     onModelOperation?(operation: ModelOperation): Promise<void>;
+    /** Load only an original completed response needed for replay. The SaaS owns
+     * its immutable archive and scope checks; metadata remains in the checkpoint. */
+    loadModelResponse?(context: Readonly<CloudExecutionContext>, operation: Readonly<ModelOperation>): Promise<NonNullable<ModelOperation["response"]>>;
     /** Product/model service atomically reserves money or token quota before network I/O. */
     reserveModelBudget?(context: Readonly<CloudExecutionContext>, operation: Omit<ModelOperation, "response">, request: LLMRequest, signal?: AbortSignal): Promise<{
         reference: string;

package/dist/types/embedded/cloud-task.d.ts

@@ -66,6 +66,13 @@ export interface CloudTaskStore {
     /** CAS + live lease check + snapshot + next contiguous event cursor in one transaction. */
     update(context: CloudExecutionContext, id: string, expectedRevision: number, task: CloudTaskSnapshot, event: CloudTaskEventPayload, leaseId?: string): Promise<CloudTaskSnapshot>;
     release(context: CloudExecutionContext, id: string, leaseId: string): Promise<void>;
+    /** Text-only CAS event append without resending unchanged task history. */
+    appendDelta?(context: CloudExecutionContext, id: string, expectedRevision: number, event: Extract<CloudTurnEvent, {
+        type: "delta";
+    }>, leaseId: string): Promise<{
+        revision: number;
+        cursor: number;
+    }>;
     events(context: CloudExecutionContext, id: string, after: number, limit: number): Promise<CloudTaskEvent[]>;
     /** Atomic lease invalidation. Preserve unresolved model billing/effects as reconciliation_required;
      * acknowledge cancelled only when their outcomes are known. Terminal tasks stay unchanged. */

package/dist/types/embedded/contracts.d.ts

@@ -46,6 +46,7 @@ export interface TurnRequest {
     continuation?: {
         completedRounds: number;
         usage: TokenUsage;
+        pendingOutputText?: string;
     };
 }
 export interface EmbeddedRuntimeOptions {
@@ -82,6 +83,8 @@ export interface TurnCheckpoint {
     messages: ChatMessage[];
     completedRounds: number;
     usage: TokenUsage;
+    /** Committed partial final output, retained across response-capacity continuations. */
+    pendingOutputText?: string;
 }
 export interface EmbeddedAgent {
     run(request: TurnRequest, signal?: AbortSignal): AsyncGenerator<TurnEvent>;

package/dist/types/embedded/core-tools.d.ts

@@ -0,0 +1,125 @@
+import type { ToolDefinition, ToolResult } from "./contracts.js";
+import type { CloudToolInvocation, CloudToolWait } from "./cloud-agent.js";
+export interface CoreResourceRead {
+    resourceId: string;
+    version?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface CorePlanStep {
+    id: string;
+    description: string;
+    status: "pending" | "in_progress" | "completed" | "blocked" | "cancelled";
+    dependsOn?: string[];
+    evidenceRefs?: string[];
+}
+export interface CorePlanIssue {
+    id: string;
+    description: string;
+    stepIds?: string[];
+}
+export interface CorePlanSnapshot {
+    steps: CorePlanStep[];
+    issues: CorePlanIssue[];
+    notes?: CorePlanNote[];
+}
+export interface CorePlanNote {
+    id: string;
+    category: "decision" | "constraint" | "blocker";
+    value: string;
+    evidenceRefs?: string[];
+}
+export interface CorePlanPatch {
+    upsertSteps?: CorePlanStep[];
+    removeStepIds?: string[];
+    upsertIssues?: CorePlanIssue[];
+    removeIssueIds?: string[];
+    upsertNotes?: CorePlanNote[];
+    removeNoteIds?: string[];
+}
+export type CorePlanInput = {
+    action: "read";
+    planId: string;
+    cursor?: string;
+    limit?: number;
+    stepIds?: string[];
+} | ({
+    action: "create";
+} & CorePlanSnapshot) | ({
+    action: "update";
+    planId: string;
+    expectedRevision: string;
+} & CorePlanSnapshot) | ({
+    action: "patch";
+    planId: string;
+    expectedRevision: string;
+} & CorePlanPatch);
+export interface CoreConfirmationInput {
+    /** Immutable prepared-operation reference issued and resolved by the Host. */
+    operationRef: string;
+    summary: string;
+    targets: {
+        resourceId: string;
+        version?: string;
+    }[];
+    impacts: string[];
+}
+export interface CoreToolInputs {
+    qlogic_ask_user: {
+        question: string;
+        choices?: string[];
+    };
+    qlogic_discover_capabilities: {
+        cursor?: string;
+    };
+    qlogic_search_resources: {
+        query: string;
+        cursor?: string;
+        limit?: number;
+    };
+    qlogic_read_resource: CoreResourceRead;
+    qlogic_read_skill: {
+        skillId: string;
+        resourceId?: string;
+        version?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    qlogic_update_plan: CorePlanInput;
+    qlogic_request_confirmation: CoreConfirmationInput;
+}
+export type CoreToolName = keyof CoreToolInputs;
+export type CoreToolWait<Name extends "qlogic_ask_user" | "qlogic_request_confirmation"> = {
+    kind: "wait";
+    wait: Omit<CloudToolWait["wait"], "kind"> & {
+        kind: Name extends "qlogic_ask_user" ? "input" : "confirmation";
+    };
+};
+export type CoreToolHandler<Name extends CoreToolName> = (input: Readonly<CoreToolInputs[Name]>, invocation: Readonly<CloudToolInvocation>, signal?: AbortSignal) => Promise<ToolResult | (Name extends "qlogic_ask_user" | "qlogic_request_confirmation" ? CoreToolWait<Name> : never)>;
+export interface CoreToolHost {
+    /** Revalidate the actor and exact resource/Skill reference on every invocation.
+     * A model-provided reference is never evidence of access or approval.
+     */
+    authorize(invocation: Readonly<CloudToolInvocation>, input: Readonly<CoreToolInputs[CoreToolName]>, signal?: AbortSignal): Promise<void>;
+    handlers: {
+        [Name in CoreToolName]?: CoreToolHandler<Name>;
+    };
+}
+export interface CoreToolAdapter {
+    /** Only explicitly mounted Host handlers are offered to the model. */
+    readonly definitions: ToolDefinition[];
+    handles(name: string): boolean;
+    invoke(invocation: CloudToolInvocation, signal?: AbortSignal): Promise<ToolResult | CloudToolWait>;
+}
+/** Artifact inventory, independent of any product's currently mounted handlers. */
+export declare function getCoreToolDefinitions(): ToolDefinition[];
+/** Pure contract validation for a Host's locked snapshot; it owns CAS and persistence. */
+export declare function applyCorePlanPatch(snapshot: CorePlanSnapshot, patch: CorePlanPatch): CorePlanSnapshot;
+/** A typed dispatch adapter for the existing CloudAgent/CloudTask tool loop.
+ * The Host owns discovery, data, authorization, plans and user-decision receipts.
+ */
+export declare function createCoreToolAdapter(options: {
+    host: CoreToolHost;
+    /** Omit to enable the supplied handlers; an explicit list must have every handler. */
+    enabledTools?: readonly CoreToolName[];
+}): CoreToolAdapter;

package/dist/types/embedded/index.d.ts

@@ -3,6 +3,9 @@ export { prepareSlidingWindowContext } from "./context-projection.js";
 export { corePackageVersion } from "./package-version.js";
 export { getCoreCapabilities } from "./core-capabilities.js";
 export type { CoreCapabilities } from "./core-capabilities.js";
+export { createCoreToolAdapter, applyCorePlanPatch } from "./core-tools.js";
+export type { CorePlanPatch, CorePlanNote } from "./core-tools.js";
+export type { CoreToolAdapter, CoreToolHost, CoreToolInputs, CoreToolName, CoreToolHandler, CoreToolWait, CoreResourceRead, CorePlanStep, CorePlanIssue, CorePlanSnapshot, CorePlanInput, CoreConfirmationInput } from "./core-tools.js";
 export { AgentContentBlockValidationError, parseAgentContentBlock, } from "./content-blocks.js";
 export type { ContextAnchor, ContextEnvelope, SemanticToolCapability, ToolIdentity, UsageRecord, UsageSource, AgentLogger, ChatMessage, CreateEmbeddedAgentOptions, EmbeddedAgent, EmbeddedRuntimeOptions, ModelContextPreparation, ModelContextProjection, LLMChunk, LLMRequest, LLMTransport, ModelRetryAuthorization, ToolDefinition, ToolInvoker, ToolInvocationContext, ToolResult, TurnCheckpoint, TokenUsage, TurnConfig, TurnEvent, TurnRequest, } from "./contracts.js";
 export type { ModelOperation, ModelRecoveryProof } from "./model-operation.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaozhiclaw/qlogicagent-core",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Shared SaaS Agent inference and durable task runtime",
   "type": "module",
   "main": "dist/index.js",