@opengeni/runtime 4.0.1 → 4.0.3-canary.36079201993001

package/src/bundled_default_skills/opengeni-client/references/discovery-and-autonomy.md

@@ -52,6 +52,37 @@ Group tightly related unresolved decisions when that makes them easier to answer
 
 For a missing privacy answer, default provisionally to the smaller sharing boundary and explain the operational cost. Do not silently weaken isolation to reduce workspace count.
 
+### Keep product choices lightweight
+
+When meaningful choices remain, group them into one short question interaction
+using the host's existing structured human-input UI when available, or a concise
+chat question otherwise. Recommend the setup that fits the product and let the
+user accept it or adjust individual choices. Do not build a new questionnaire or
+ask every integration the same questions. A suggested answer is not consent to
+send data, share private content, or perform an external action.
+
+Use product language for the relevant unresolved choices:
+
+- **Learning across chats:** no new lasting learning, remember for each person,
+  or shared team knowledge. Explain briefly that chat history/retention is separate
+  and disabling learning does not delete history or existing authorized Knowledge.
+- **Who can open chats:** only their owner, the team, or a choice on each chat.
+  Keep human visibility separate from agent access and Knowledge scope. Choose the
+  workspace mapping from the actual sharing boundary; private chats alone do not
+  require a workspace per person.
+- **How the agent gets data:** current-page snapshots, read-only tools to fetch
+  more reports, or controlled queries for deeper analysis. State the meaningful
+  limitation of the recommendation. Confirm broader access or writes separately
+  only when they are part of the requested product.
+
+For example, if all three choices are unresolved for a simple dashboard, propose
+“Private chats, no learning between chats, and current-page data only” with a short
+explanation that the agent cannot fetch another report on its own. Do not reuse
+that default for a team assistant whose requirements already imply shared work.
+Continue independent discovery while awaiting an answer; ask again only when new
+information introduces a material decision. Summarize any provisional choices in
+the handoff so they do not become invisible product decisions.
+
 ## Follow the wanted autonomy
 
 Infer the delivery mode from explicit user language first, then repository guidance and established team workflow:

package/src/bundled_default_skills/opengeni-client/references/runtime-profile-and-verification.md

@@ -154,4 +154,36 @@ silently linking identities or widening membership. Complete discoverable setup
 before handoff; identify operator-only blockers separately and do not depend on
 internal source, cluster access, prior chat memory, or undocumented local helpers.
 
+### Make the next step easy
+
+Keep the user-facing handoff short: what works, what was verified, and the next
+action needed to make it usable. Put detailed commands and configuration in the
+repository setup guide and link it. When setup is blocked, show a compact checklist
+in the conversation using existing text/link UI; no new setup-card renderer is
+required.
+
+For missing OpenGeni credentials, point to the selected deployment's Organization
+settings: the overview shows **Organization ID** with a copy control, and
+**Developer** contains **Create Organization API Key** plus another ID copy
+control. Prefer a verified settings link or returned setup action over an invented
+URL. Verify older/self-hosted UI availability before promising these controls.
+Explain the key type and required access for the implemented calls: workspace
+provisioning and chat writes need a write-capable organization key, not a read-only
+key. State its actual scope without inventing granular permission switches.
+
+Name the exact server configuration variables and secret-store destination. Fill
+verified non-secret IDs yourself when authorized and unambiguous. Give a secure
+interactive command or secret-manager action for the key; never ask the user to
+paste a secret into chat or put it in a browser variable. Follow with the actual
+deployment command/target and a first-question smoke test, including model/billing
+readiness when unverified. Complete authorized steps yourself; clearly identify
+any remaining owner login, secret entry, or deployment approval.
+
+Resolve ordinary missing tools using the project's supported installation or
+package-runner path where possible. Investigate dependency warnings enough to
+state their effect and available fix. Surface only material unresolved risks or
+user actions in plain language; keep routine audit counts and logs in the setup
+or verification notes. Do not claim a warning is harmless without evidence, or
+make unrelated upgrades merely to silence the report.
+
 If a durable customer integration Skill would reduce future rediscovery, generate one beside the integration code containing only stable, non-secret project facts and smoke probes. Do not turn the generic implementation Skill into the customer's analytics prompt, and do not make generated runtime behavior depend on the implementation workspace retaining this implementation Skill.

package/src/context-compaction.ts

@@ -43,6 +43,10 @@ export type CompactionItem = Record<string, unknown>;
 export const COMPACTION_SUMMARY_MARKER = "opengeni_context_summary";
 
 export const SUMMARY_BUFFER_TOKENS = 20_000;
+/** Leave input room on models whose entire context is smaller than the normal reserve. */
+export function compactionSummaryOutputTokens(contextWindowTokens: number): number {
+  return Math.min(SUMMARY_BUFFER_TOKENS, Math.max(1, Math.floor(contextWindowTokens / 4)));
+}
 // A single cumulative budget for all retained real user messages, matching
 // Codex core's build_compacted_history_with_limit (not a per-message allowance).
 export const COMPACT_USER_MESSAGE_MAX_TOKENS = 20_000;
@@ -1243,7 +1247,7 @@ export class EmptyCompactionSummaryError extends Error {
   constructor(diagnostics: Record<string, unknown> = {}) {
     const compact = JSON.stringify(diagnostics).slice(0, 2_000);
     super(
-      `Compaction summarizer returned no assistant text; active history was preserved${compact ? ` (${compact})` : ""}`,
+      `Compaction could not produce a usable checkpoint; active history was preserved${compact ? ` (${compact})` : ""}`,
     );
     this.name = "EmptyCompactionSummaryError";
     this.diagnostics = diagnostics;
@@ -1520,10 +1524,18 @@ export function omitOpaqueArtifactsFromPortableCompactionHistory(
     }
     if (type === "reasoning" && hasOpaqueProviderArtifact(item)) {
       const projected = projectRejectedReasoningArtifact(item);
+      if (Object.keys(projected).length === 1) {
+        changed = true;
+        continue;
+      }
       changed ||= projected !== item;
       out.push(projected as CompactionItem);
       continue;
     }
+    if (type === "reasoning" && Object.keys(item).length === 1) {
+      changed = true;
+      continue;
+    }
     out.push(item);
   }
   return changed ? out : (items as CompactionItem[]);
@@ -1605,16 +1617,20 @@ function oldestLogicalUnitCuts(items: readonly CompactionItem[]): number[] {
 
 /**
  * Build the active history after compaction:
- * the newest real user messages that fit one cumulative 20k-token budget
+ * the newest real user messages that fit one cumulative, model-bounded budget
  * (prior summaries excluded, retained images preserved) plus one marked summary item.
  */
 export function buildCompactionReplacementHistory(
   items: readonly CompactionItem[],
   summaryBody: string,
   retainedItemTokens: (item: CompactionItem) => number = (item) => estimateTokens([item]),
+  retainedMessageBudgetTokens = COMPACT_USER_MESSAGE_MAX_TOKENS,
 ): CompactionItem[] {
   const retainedReversed: CompactionItem[] = [];
-  let remaining = COMPACT_USER_MESSAGE_MAX_TOKENS;
+  let remaining = Math.max(
+    0,
+    Math.min(COMPACT_USER_MESSAGE_MAX_TOKENS, retainedMessageBudgetTokens),
+  );
   for (let index = items.length - 1; index >= 0 && remaining > 0; index -= 1) {
     const item = items[index]!;
     if (!isUserMessage(item) || isCompactionSummary(item) || isAttachmentCatalog(item)) {

package/src/index.ts

@@ -253,7 +253,7 @@ import { OPENGENI_OPERATIONAL_INSTRUCTIONS } from "./operational-instructions";
 import {
   CompactionProviderResponseError,
   EmptyCompactionSummaryError,
-  SUMMARY_BUFFER_TOKENS,
+  compactionSummaryOutputTokens,
   buildRemoteCompactionV2PromptInput,
   extractRemoteCompactionV2OutputItem,
   estimateSerializedValueTokens,
@@ -262,6 +262,7 @@ import {
 } from "./context-compaction";
 import {
   createSandboxClient,
+  isModalTaskExecStartPreDispatchUnavailableError,
   isRoutingMutationOutcomeUnknownError,
   repairSerializedRunStateExposedPorts,
   restoredSandboxSessionStateFromEntry,
@@ -655,6 +656,7 @@ export {
   MIN_COMPACTION_THRESHOLD_RATIO,
   MAX_COMPACTION_THRESHOLD_RATIO,
   SUMMARY_BUFFER_TOKENS,
+  compactionSummaryOutputTokens,
   SUMMARY_PREFIX,
   USER_MESSAGE_TRUNCATION_MARKER,
   REMOTE_COMPACTION_TOOL_RESULT_OMISSION,
@@ -1004,17 +1006,17 @@ export async function generateSessionTitle(
  * call against the resolved provider. `input` is the active history plus
  * Codex's checkpoint prompt. Provider failures propagate to the compaction
  * lifecycle; there is no non-model fallback that silently discards history.
- * The call deliberately does NOT
- * request reasoning encryption, tools, or inline provider compaction; it is a
- * self-contained summarize.
+ * It is a single summary call: prepared Responses requests retain tool schemas
+ * and provider settings for the existing prefix, but tool selection is disabled
+ * and no tool execution loop or inline provider compaction runs.
  *
  * Provider-aware: the summary always runs on the SAME provider that serves the
  * turn (registry providers can't summarize through OpenAI/Azure, and vice
  * versa). `api: "chat"` providers (Fireworks) speak /v1/chat/completions, where
  * the summary is choices[0].message.content; `api: "responses"` (the default,
  * built-in OpenAI/Azure) speaks /v1/responses as before. When no client/api is
- * supplied it uses the built-in OpenAI/Azure Responses path. store:false is set
- * only on the OpenAI-platform Responses path (Azure rejects it; chat ignores it).
+ * supplied it uses the built-in OpenAI/Azure Responses path. Non-Azure Responses
+ * requests use store:false; the resolved Azure wire profile omits it.
  */
 export async function summarizeForCompaction(
   settings: Settings,
@@ -1027,6 +1029,8 @@ export async function summarizeForCompaction(
     model?: string;
     promptCacheKey?: string;
     systemInstructions?: string;
+    preparedRequest?: Omit<ModelRequest, "input">;
+    signal?: AbortSignal;
     onUsage?: (usage: ModelResponseUsage) => void | Promise<void>;
   } = {},
 ): Promise<string> {
@@ -1035,17 +1039,27 @@ export async function summarizeForCompaction(
   const model = options.model ?? settings.openaiModel;
   const provider = options.provider ?? configuredProviders(settings)[0];
   if (!provider) throw new Error("Built-in model provider is unavailable");
-  const maxTokens = options.maxOutputTokens ?? SUMMARY_BUFFER_TOKENS;
+  const azureResponses = provider.wireProfile === "azure-openai";
+  const maxTokens =
+    options.maxOutputTokens ?? compactionSummaryOutputTokens(settings.contextWindowTokens);
   if (api === "chat") {
     const transcript = renderCompactionPromptInputForChat(input);
     let completion: unknown;
     try {
-      completion = await client.chat.completions.create({
-        model,
-        max_tokens: maxTokens,
-        messages: [{ role: "user", content: transcript }],
-        ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
-      } as any);
+      completion = await client.chat.completions.create(
+        {
+          model,
+          max_tokens: maxTokens,
+          messages: [
+            ...(options.systemInstructions
+              ? [{ role: "system" as const, content: options.systemInstructions }]
+              : []),
+            { role: "user", content: transcript },
+          ],
+          ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
+        } as any,
+        options.signal ? { signal: options.signal } : undefined,
+      );
     } catch (error) {
       throw new CompactionProviderResponseError(compactionProviderFailureDiagnostics(error), error);
     }
@@ -1053,8 +1067,23 @@ export async function summarizeForCompaction(
     if (usage) {
       await options.onUsage?.(usage);
     }
-    const text = (completion as { choices?: Array<{ message?: { content?: unknown } }> })
-      .choices?.[0]?.message?.content;
+    const choice = (
+      completion as {
+        choices?: Array<{ finish_reason?: unknown; message?: { content?: unknown } }>;
+      }
+    ).choices?.[0];
+    if (choice?.finish_reason !== "stop") {
+      throw new EmptyCompactionSummaryError({
+        stage: "chat_completion",
+        reason: "non_stop_finish",
+        finishReason: ["length", "content_filter", "tool_calls", "function_call"].includes(
+          String(choice?.finish_reason),
+        )
+          ? choice?.finish_reason
+          : "unknown",
+      });
+    }
+    const text = choice.message?.content;
     const summary = typeof text === "string" ? text.trim() : "";
     if (!summary) {
       throw new EmptyCompactionSummaryError(compactionResponseDiagnostics(completion, summary));
@@ -1064,27 +1093,54 @@ export async function summarizeForCompaction(
   // Use the same SDK Responses adapter as the real agent call. It converts the
   // structured AgentInputItems (callId/providerData/etc.) to provider wire
   // items without flattening tool history into a fake user transcript.
-  const request: ModelRequest = {
-    systemInstructions: options.systemInstructions ?? "",
-    input: input.map(detachCompactionResponseItemIdentity) as AgentInputItem[],
-    modelSettings: {
-      maxTokens,
-      // Azure can select a historical tool despite empty schemas. Keep this
-      // verified policy off subscription/gateway transports with other contracts.
-      ...(provider.wireProfile === "azure-openai" ? { toolChoice: "none" as const } : {}),
-      // Azure rejects store:false; the Codex subscription transport enforces
-      // it independently. The OpenAI platform path remains explicitly storeless.
-      ...(settings.openaiProvider === "azure" ? {} : { store: false }),
-      ...(options.promptCacheKey
-        ? { providerData: { prompt_cache_key: options.promptCacheKey } }
-        : {}),
-    },
-    tools: [],
-    toolsExplicitlyProvided: true,
-    outputType: "text",
-    handoffs: [],
-    tracing: false,
-  };
+  // The captured inference signal may have been aborted when its stream
+  // stopped. Compaction must use the still-active turn signal instead.
+  const preparedPrefix = options.preparedRequest
+    ? (({ signal: _priorSignal, ...prefix }) => prefix)(options.preparedRequest)
+    : null;
+  const { store: _priorStore, ...preparedModelSettings } = preparedPrefix?.modelSettings ?? {};
+  const request: ModelRequest = preparedPrefix
+    ? {
+        ...preparedPrefix,
+        // The history copy is still portable: dependent stored response ids are
+        // removed, and the final checkpoint instruction is appended by the caller.
+        input: input.map(detachCompactionResponseItemIdentity) as AgentInputItem[],
+        modelSettings: {
+          ...preparedModelSettings,
+          maxTokens,
+          // Retain schemas for the warm prefix without letting the checkpoint
+          // model select or execute a tool (including a historical Azure tool).
+          toolChoice: "none",
+          // The selected provider, not the deployment default, owns this wire
+          // policy. Override any inherited value on a prepared Azure request.
+          ...(azureResponses ? {} : { store: false }),
+        },
+        outputType: "text",
+        tracing: false,
+        ...(options.signal ? { signal: options.signal } : {}),
+      }
+    : {
+        systemInstructions: options.systemInstructions ?? "",
+        input: input.map(detachCompactionResponseItemIdentity) as AgentInputItem[],
+        modelSettings: {
+          maxTokens,
+          // Azure can select a historical tool despite empty schemas. Keep this
+          // verified policy off subscription/gateway transports with other contracts.
+          ...(azureResponses ? { toolChoice: "none" as const } : {}),
+          // Azure rejects store:false; the Codex subscription transport enforces
+          // it independently. Other Responses routes remain explicitly storeless.
+          ...(azureResponses ? {} : { store: false }),
+          ...(options.promptCacheKey
+            ? { providerData: { prompt_cache_key: options.promptCacheKey } }
+            : {}),
+        },
+        tools: [],
+        toolsExplicitlyProvided: true,
+        outputType: "text",
+        handoffs: [],
+        tracing: false,
+        ...(options.signal ? { signal: options.signal } : {}),
+      };
   let response: unknown;
   try {
     response = await new CompactionResponsesModel(client, model, provider).fetchResponse(request);
@@ -3630,6 +3686,14 @@ function buildAgentCapabilitiesFromComposition(
   const caps: ReturnType<typeof Capabilities.default> = [
     filesystemCapability,
     shell({
+      // The SDK normally renders every shell error into model-facing text.
+      // Preserve that behavior except for client-side, pre-dispatch Modal
+      // readiness proof, which reaches bounded same-turn recovery.
+      execCommandErrorFunction: (_context, error) => {
+        if (isModalTaskExecStartPreDispatchUnavailableError(error)) throw error;
+        const details = error instanceof Error ? error.toString() : String(error);
+        return `An error occurred while running the tool. Please try again. Error: ${details}`;
+      },
       ...(toolCancellation ? {} : { configureTools: withExecOpCorrelation }),
     }),
   ];