@opencode/core 0.0.0-reserved → 2.0.0

package/dist/types/session/error.d.ts

@@ -0,0 +1,135 @@
+export * as SessionErrors from "./error.js";
+import { Schema } from "effect";
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Session.NotFoundError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+}
+declare const MessageNotFoundError_base: Schema.Class<MessageNotFoundError, Schema.TaggedStruct<"Session.MessageNotFoundError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageNotFoundError extends MessageNotFoundError_base {
+}
+declare const ForkEmptyError_base: Schema.Class<ForkEmptyError, Schema.TaggedStruct<"Session.ForkEmptyError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ForkEmptyError extends ForkEmptyError_base {
+    get message(): string;
+}
+declare const MessageDecodeError_base: Schema.Class<MessageDecodeError, Schema.TaggedStruct<"Session.MessageDecodeError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageDecodeError extends MessageDecodeError_base {
+    get message(): string;
+}
+declare const AgentNotFoundError_base: Schema.Class<AgentNotFoundError, Schema.TaggedStruct<"Session.AgentNotFoundError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly agent: Schema.brand<Schema.String, "Agent.ID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentNotFoundError extends AgentNotFoundError_base {
+    get message(): string;
+}
+declare const StepFailedError_base: Schema.Class<StepFailedError, Schema.TaggedStruct<"Session.StepFailedError", {
+    readonly error: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly message: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+export declare class StepFailedError extends StepFailedError_base {
+    get message(): string;
+}
+declare const UserInterruptedError_base: Schema.Class<UserInterruptedError, Schema.TaggedStruct<"Session.UserInterruptedError", {}>, import("effect/Cause").YieldableError>;
+export declare class UserInterruptedError extends UserInterruptedError_base {
+    get message(): string;
+}
+declare const PromptConflictError_base: Schema.Class<PromptConflictError, Schema.TaggedStruct<"Session.PromptConflictError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class PromptConflictError extends PromptConflictError_base {
+}
+declare const SyntheticConflictError_base: Schema.Class<SyntheticConflictError, Schema.TaggedStruct<"Session.SyntheticConflictError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class SyntheticConflictError extends SyntheticConflictError_base {
+}
+declare const AttachmentError_base: Schema.Class<AttachmentError, Schema.TaggedStruct<"Session.AttachmentError", {
+    readonly uri: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AttachmentError extends AttachmentError_base {
+}
+declare const CompactionConflictError_base: Schema.Class<CompactionConflictError, Schema.TaggedStruct<"Session.CompactionConflictError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class CompactionConflictError extends CompactionConflictError_base {
+}
+declare const BusyError_base: Schema.Class<BusyError, Schema.TaggedStruct<"Session.BusyError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class BusyError extends BusyError_base {
+}
+declare const InboxConflictError_base: Schema.Class<InboxConflictError, Schema.TaggedStruct<"Session.InboxConflictError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly inboxID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class InboxConflictError extends InboxConflictError_base {
+}
+declare const SkillNotFoundError_base: Schema.Class<SkillNotFoundError, Schema.TaggedStruct<"Session.SkillNotFoundError", {
+    readonly skill: Schema.brand<Schema.String, "Skill.ID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class SkillNotFoundError extends SkillNotFoundError_base {
+}

package/dist/types/session/event.d.ts

@@ -0,0 +1,2 @@
+export * from "@opencode/schema/session-event";
+export * as SessionEvent from "@opencode/schema/session-event";

package/dist/types/session/execution/restart.d.ts

@@ -0,0 +1,48 @@
+export * as SessionRestart from "./restart.js";
+import { Context, Effect, Layer } from "effect";
+import { Bus } from "../../bus.js";
+import { Job } from "../../job.js";
+import { Session } from "../../session.js";
+import { SessionExecution } from "../execution.js";
+import { SessionStore } from "../store.js";
+export interface Options {
+    /**
+     * Times a single turn may be resumed before it is terminalized instead.
+     * The counter is durable and only a terminal event resets it, so a turn
+     * that keeps dying cannot crash-loop across restarts. Turns that complete
+     * never accumulate: the budget is per-turn, not per-session.
+     */
+    readonly maxAttempts?: number;
+}
+export interface Interface {
+    /**
+     * Resumes Sessions whose execution claim was never released — turns orphaned
+     * by a process that died without teardown, or interrupted by a graceful
+     * shutdown (which preserves the claim on purpose). The claim is never
+     * cleared here: only a terminal event releases it, so a death anywhere in
+     * the resume path leaves the same orphaned claim for the next boot.
+     */
+    readonly resumeSuspendedSessions: Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRestart", Interface>;
+/**
+ * Recovery for orphaned executions. Claims are written at turn start by
+ * SessionExecution, so this sweep needs no cooperation from the previous
+ * process: crash, SIGKILL, isolate eviction, and graceful restart all leave
+ * the same durable signature.
+ *
+ * Recovery is at-least-once: local coordination prevents concurrent drains,
+ * not repeated external side effects after a crash.
+ *
+ * The sweep assumes every orphaned claim's owner is dead. The managed-server
+ * protocol guarantees this: a successor is only spawned after the previous
+ * process is confirmed dead (client service `kill`/`evict` poll the PID), the
+ * registration lock admits one managed server at a time, and unregistered
+ * servers sharing the database never sweep. The service is inert until called
+ * — the managed server invokes it at boot; embedders may call it from their
+ * own start-up.
+ */
+export declare class Service extends Service_base {
+}
+export declare const layer: (options?: Options) => Layer.Layer<Service, never, Bus.Service | SessionStore.Service | Session.Service | Job.Service | SessionExecution.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/session/execution.d.ts

@@ -0,0 +1,56 @@
+export * as SessionExecution from "./execution.js";
+import { Context, Effect, Exit, Layer } from "effect";
+import { Bus } from "../bus.js";
+import { Database } from "../database/database.js";
+import { Job } from "../job.js";
+import { Instance } from "../instance/service.js";
+import { SessionRunner } from "./runner/index.js";
+import { SessionSchema } from "./schema.js";
+import { SessionStore } from "./store.js";
+export interface Interface {
+    /** Snapshots active execution owned by this process. */
+    readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>;
+    /** Checks process-local ownership, including interruption cleanup and terminal settlement. */
+    readonly isActive: (sessionID: SessionSchema.ID) => Effect.Effect<boolean>;
+    /** Starts execution while idle or joins the active execution. */
+    readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, SessionRunner.RunError>;
+    /** Registers newly recorded work. Repeated wakeups may coalesce. */
+    readonly wake: (sessionID: SessionSchema.ID) => Effect.Effect<void>;
+    /**
+     * Interrupt active work owned by this process. Idle interruption is a no-op. Resolves once
+     * the interruption is accepted; cleanup settles asynchronously in the execution fiber.
+     * Returns whether an active execution was interrupted. Compose with `awaitIdle` when
+     * settlement matters. `awaitSettlement` waits only for the interrupted execution,
+     * rather than fresh work admitted during its cleanup.
+     */
+    readonly interrupt: (sessionID: SessionSchema.ID, options?: {
+        readonly continue?: boolean;
+        readonly reason?: "user" | "inactivity";
+        readonly awaitSettlement?: boolean;
+    }) => Effect.Effect<boolean>;
+    /** Resolves once this process owns no active execution for the Session. Returns immediately when idle and never starts work. */
+    readonly awaitIdle: (sessionID: SessionSchema.ID) => Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionExecution", Interface>;
+/** Routes execution from a Session ID to its selected instance's runner. */
+export declare class Service extends Service_base {
+}
+type InterruptReason = "user" | "shutdown" | "inactivity";
+export declare function terminal(exit: Exit.Exit<void, SessionRunner.RunError>, reason?: InterruptReason): {
+    type: "succeeded";
+    reason?: undefined;
+    error?: undefined;
+} | {
+    type: "interrupted";
+    reason: InterruptReason;
+    error?: undefined;
+} | {
+    type: "failed";
+    error: import("@opencode/schema/session-error").Error;
+    reason?: undefined;
+};
+/** Process-local execution: drains run in this process using the selected instance. */
+export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | SessionStore.Service | Job.Service | Instance.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;
+/** Low-level compatibility layer for callers that only need durable Session recording. */
+export declare const noopLayer: Layer.Layer<Service, never, never>;

package/dist/types/session/generate.d.ts

@@ -0,0 +1,15 @@
+export * as SessionGenerate from "./generate.js";
+import { type AIError } from "@opencode/ai";
+import { Effect } from "effect";
+import { Database } from "../database/database.js";
+import { Instance } from "../instance/service.js";
+import type { Instructions } from "../instructions/index.js";
+import type { AgentNotFoundError } from "./error.js";
+import type { SessionRunnerModel } from "./runner/model.js";
+import type { SessionSchema } from "./schema.js";
+export type Error = AgentNotFoundError | Instructions.InitializationBlocked | SessionRunnerModel.Error | AIError;
+/** Generates text from current Session context without mutating the Session. */
+export declare const generate: (input: {
+    session: SessionSchema.Info;
+    prompt: string;
+}) => Effect.Effect<string, AIError | AgentNotFoundError | Instructions.InitializationBlocked | SessionRunnerModel.Error, Database.Service | import("@opencode/ai").LLMClientService | Instance.Service>;