@od-oneapp/ai-platform 0.1.0

package/dist/schema-Wz-1-ro9.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-Wz-1-ro9.d.mts","names":[],"sources":["../src/agents/workflows/interfaces.ts","../src/agents/workflows/schema.ts"],"mappings":";;;UAWiB,YAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA,CAAQ,KAAA,EAAO,MAAA,GAAS,OAAA,CAAQ,OAAA;AAAA;AAAA,UAMjB,QAAA;EACf,EAAA;EACA,KAAA,EAAO,MAAA;EACP,KAAA,EAAO,YAAA;EAGP,GAAA,IAAO,OAAA,CAAQ,MAAA;AAAA;AAAA,UAMA,eAAA;EACf,SAAA,CAAU,KAAA,EAAO,CAAA;EACjB,WAAA,CAAY,IAAA,WAAe,CAAA;AAAA;;;cCxBhB,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;;;;;;KASpB,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA"}

package/dist/schemas-CxQtxIga.mjs

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+//#region src/governance/compliance/schemas.ts
+/**
+* @fileoverview Compliance schemas — risk levels and compliance signals.
+*
+* RiskLevel and ComplianceSignal are governance-domain concepts used across
+* agents, tools, and policies for audit and compliance purposes.
+*
+* @module @od-oneapp/ai-platform/governance/compliance/schemas
+*/
+/** Valid risk level values. */
+const riskLevels = [
+	"low",
+	"medium",
+	"high"
+];
+/**
+* Schema for compliance signals.
+* Represents events emitted during agent execution for compliance and audit purposes.
+* @example
+* ```ts
+* const signal = complianceSignalSchema.parse({
+*   id: 'sig-1',
+*   type: 'tool.executed',
+*   message: 'auditLog executed',
+*   runId: 'run-123',
+*   timestamp: new Date().toISOString(),
+* });
+* ```
+*/
+const complianceSignalSchema = z.object({
+	id: z.string(),
+	type: z.enum([
+		"guardrail.blocked",
+		"guardrail.sanitized",
+		"tool.awaiting-approval",
+		"tool.executed",
+		"tool.denied",
+		"loop.stopped",
+		"loop.started",
+		"loop.completed",
+		"loop.exhausted",
+		"loop.error",
+		"loop.timeout",
+		"loop.budget_exceeded",
+		"loop.approval_required"
+	]),
+	message: z.string(),
+	runId: z.string().describe("Agent run associated with the signal"),
+	riskLevel: z.union([
+		z.literal("low"),
+		z.literal("medium"),
+		z.literal("high")
+	]).optional().describe("Risk level classification"),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	timestamp: z.string().describe("ISO timestamp for ordering in the UI")
+});
+
+//#endregion
+export { riskLevels as n, complianceSignalSchema as t };
+//# sourceMappingURL=schemas-CxQtxIga.mjs.map

package/dist/schemas-CxQtxIga.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-CxQtxIga.mjs","names":[],"sources":["../src/governance/compliance/schemas.ts"],"sourcesContent":["/**\n * @fileoverview Compliance schemas — risk levels and compliance signals.\n *\n * RiskLevel and ComplianceSignal are governance-domain concepts used across\n * agents, tools, and policies for audit and compliance purposes.\n *\n * @module @od-oneapp/ai-platform/governance/compliance/schemas\n */\n\nimport { z } from 'zod';\n\n/** Valid risk level values. */\nexport const riskLevels = ['low', 'medium', 'high'] as const;\n\n/** Risk level type ('low', 'medium', or 'high'). */\nexport type RiskLevel = (typeof riskLevels)[number];\n\n/**\n * Schema for compliance signals.\n * Represents events emitted during agent execution for compliance and audit purposes.\n * @example\n * ```ts\n * const signal = complianceSignalSchema.parse({\n *   id: 'sig-1',\n *   type: 'tool.executed',\n *   message: 'auditLog executed',\n *   runId: 'run-123',\n *   timestamp: new Date().toISOString(),\n * });\n * ```\n */\nexport const complianceSignalSchema = z.object({\n  /** Unique signal identifier. */\n  id: z.string(),\n  /** Signal type indicating the event category. */\n  type: z.enum([\n    'guardrail.blocked',\n    'guardrail.sanitized',\n    'tool.awaiting-approval',\n    'tool.executed',\n    'tool.denied',\n    'loop.stopped',\n    // Governance Agent signals\n    'loop.started',\n    'loop.completed',\n    'loop.exhausted',\n    'loop.error',\n    'loop.timeout',\n    'loop.budget_exceeded',\n    'loop.approval_required',\n  ]),\n  /** Human-readable message describing the signal. */\n  message: z.string(),\n  /** Agent run associated with the signal. */\n  runId: z.string().describe('Agent run associated with the signal'),\n  /** Risk level classification. */\n  riskLevel: z\n    .union([z.literal('low'), z.literal('medium'), z.literal('high')])\n    .optional()\n    .describe('Risk level classification'),\n  /** Optional metadata for additional context. */\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  /** ISO timestamp for ordering in the UI. */\n  timestamp: z.string().describe('ISO timestamp for ordering in the UI'),\n});\n\n/** Compliance signal type. */\nexport type ComplianceSignal = z.infer<typeof complianceSignalSchema>;\n"],"mappings":";;;;;;;;;;;;AAYA,MAAa,aAAa;CAAC;CAAO;CAAU;CAAO;;;;;;;;;;;;;;;AAmBnD,MAAa,yBAAyB,EAAE,OAAO;CAE7C,IAAI,EAAE,QAAQ;CAEd,MAAM,EAAE,KAAK;EACX;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;CAEF,SAAS,EAAE,QAAQ;CAEnB,OAAO,EAAE,QAAQ,CAAC,SAAS,uCAAuC;CAElE,WAAW,EACR,MAAM;EAAC,EAAE,QAAQ,MAAM;EAAE,EAAE,QAAQ,SAAS;EAAE,EAAE,QAAQ,OAAO;EAAC,CAAC,CACjE,UAAU,CACV,SAAS,4BAA4B;CAExC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,UAAU;CAEtD,WAAW,EAAE,QAAQ,CAAC,SAAS,uCAAuC;CACvE,CAAC"}

package/dist/schemas-DBOhxgW7.d.mts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+
+//#region src/governance/compliance/schemas.d.ts
+declare const riskLevels: readonly ["low", "medium", "high"];
+type RiskLevel = (typeof riskLevels)[number];
+declare const complianceSignalSchema: z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodEnum<{
+    "guardrail.blocked": "guardrail.blocked";
+    "guardrail.sanitized": "guardrail.sanitized";
+    "tool.awaiting-approval": "tool.awaiting-approval";
+    "tool.executed": "tool.executed";
+    "tool.denied": "tool.denied";
+    "loop.stopped": "loop.stopped";
+    "loop.started": "loop.started";
+    "loop.completed": "loop.completed";
+    "loop.exhausted": "loop.exhausted";
+    "loop.error": "loop.error";
+    "loop.timeout": "loop.timeout";
+    "loop.budget_exceeded": "loop.budget_exceeded";
+    "loop.approval_required": "loop.approval_required";
+  }>;
+  message: z.ZodString;
+  runId: z.ZodString;
+  riskLevel: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"low">, z.ZodLiteral<"medium">, z.ZodLiteral<"high">]>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  timestamp: z.ZodString;
+}, z.core.$strip>;
+type ComplianceSignal = z.infer<typeof complianceSignalSchema>;
+//#endregion
+export { RiskLevel as n, ComplianceSignal as t };
+//# sourceMappingURL=schemas-DBOhxgW7.d.mts.map

package/dist/schemas-DBOhxgW7.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-DBOhxgW7.d.mts","names":[],"sources":["../src/governance/compliance/schemas.ts"],"mappings":";;;cAYa,UAAA;AAAA,KAGD,SAAA,WAAoB,UAAA;AAAA,cAgBnB,sBAAA,EAAsB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;KAoCvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA"}

package/dist/schemas-Dp_OCqBt.d.mts

@@ -0,0 +1,63 @@
+import { c as BaseAgentState, l as StopCondition, n as AgentConfig, s as AgentMessage, t as Agent } from "./types-DbUfMCnT.mjs";
+import { z } from "zod";
+
+//#region src/agents/base/factory.d.ts
+declare function createInitialState(messages?: AgentMessage[]): BaseAgentState;
+declare function createAgent(config: AgentConfig, stopCondition?: StopCondition): Agent;
+declare function runAgentLoop(options: {
+  maxIterations: number;
+  initialState: BaseAgentState;
+  step: (state: BaseAgentState) => Promise<BaseAgentState>;
+  shouldStop: StopCondition;
+  onStep?: (state: BaseAgentState) => void | Promise<void>;
+}): Promise<BaseAgentState>;
+//#endregion
+//#region src/agents/base/schemas.d.ts
+declare const agentToolCallSchema: z.ZodObject<{
+  id: z.ZodString;
+  toolName: z.ZodString;
+  input: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
+  approved: z.ZodOptional<z.ZodBoolean>;
+  durationMs: z.ZodOptional<z.ZodNumber>;
+  resultSummary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const agentCitationSchema: z.ZodObject<{
+  id: z.ZodString;
+  title: z.ZodString;
+  url: z.ZodOptional<z.ZodString>;
+  snippet: z.ZodString;
+  score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const agentStructuredOutputSchema: z.ZodObject<{
+  runId: z.ZodString;
+  summary: z.ZodString;
+  decision: z.ZodString;
+  riskLevel: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+  }>;
+  toolCalls: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    toolName: z.ZodString;
+    input: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
+    approved: z.ZodOptional<z.ZodBoolean>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    resultSummary: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  citations: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    snippet: z.ZodString;
+    score: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type AgentStructuredOutput = z.infer<typeof agentStructuredOutputSchema>;
+type AgentToolCall = z.infer<typeof agentToolCallSchema>;
+type AgentCitation = z.infer<typeof agentCitationSchema>;
+//#endregion
+export { agentStructuredOutputSchema as a, createInitialState as c, agentCitationSchema as i, runAgentLoop as l, AgentStructuredOutput as n, agentToolCallSchema as o, AgentToolCall as r, createAgent as s, AgentCitation as t };
+//# sourceMappingURL=schemas-Dp_OCqBt.d.mts.map

package/dist/schemas-Dp_OCqBt.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-Dp_OCqBt.d.mts","names":[],"sources":["../src/agents/base/factory.ts","../src/agents/base/schemas.ts"],"mappings":";;;;iBAyEgB,kBAAA,CAAmB,QAAA,GAAU,YAAA,KAAsB,cAAA;AAAA,iBAoMnD,WAAA,CAAY,MAAA,EAAQ,WAAA,EAAa,aAAA,GAAgB,aAAA,GAAgB,KAAA;AAAA,iBAwF3D,YAAA,CAAa,OAAA;EACjC,aAAA;EACA,YAAA,EAAc,cAAA;EACd,IAAA,GAAO,KAAA,EAAO,cAAA,KAAmB,OAAA,CAAQ,cAAA;EACzC,UAAA,EAAY,aAAA;EACZ,MAAA,IAAU,KAAA,EAAO,cAAA,YAA0B,OAAA;AAAA,IACzC,OAAA,CAAQ,cAAA;;;cChVC,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;cAiCnB,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;cA6BnB,2BAAA,EAA2B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuB5B,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,2BAAA;AAAA,KAEvC,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAE/B,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA"}

package/dist/schemas-SwCsnT0z.mjs

@@ -0,0 +1,83 @@
+import { n as riskLevels } from "./schemas-CxQtxIga.mjs";
+import { z } from "zod";
+
+//#region src/agents/base/schemas.ts
+/**
+* @fileoverview Agent output schemas — structured output, tool calls, citations.
+*
+* Defines the standard output format for agent runs including decisions,
+* tool call records, and supporting evidence.
+*
+* @module @od-oneapp/ai-platform/agents/base/schemas
+*/
+/**
+* Schema for agent tool call information.
+* Captures tool execution details for audit and compliance purposes.
+* @example
+* ```ts
+* const call = agentToolCallSchema.parse({
+*   id: 'tool-1',
+*   toolName: 'auditLog',
+*   input: { runId: '123' },
+*   approved: true,
+* });
+* ```
+*/
+const agentToolCallSchema = z.object({
+	id: z.string().describe("Stable identifier for the tool call"),
+	toolName: z.string().describe("Name of the tool that executed"),
+	input: z.unknown().refine((val) => val !== void 0, { message: "input is required" }).describe("Raw input passed to the tool"),
+	approved: z.boolean().optional().describe("Whether a human approved execution"),
+	durationMs: z.number().nonnegative().optional().describe("Execution duration in milliseconds"),
+	resultSummary: z.string().optional().describe("Short, human readable summary of the tool output")
+});
+/**
+* Schema for agent citation/reference information.
+* Represents supporting evidence or sources for agent decisions.
+* @example
+* ```ts
+* const citation = agentCitationSchema.parse({
+*   id: 'c1',
+*   title: 'Policy',
+*   url: 'https://example.com',
+*   snippet: 'Policy snippet',
+* });
+* ```
+*/
+const agentCitationSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	url: z.string().url().optional(),
+	snippet: z.string(),
+	score: z.number().min(0).max(1).optional()
+});
+/**
+* Schema for agent structured output.
+* Comprehensive output format capturing all agent decisions, tool calls, and evidence.
+* @example
+* ```ts
+* const output = agentStructuredOutputSchema.parse({
+*   runId: 'run-1',
+*   summary: 'Completed review',
+*   decision: 'approve',
+*   riskLevel: 'medium',
+*   toolCalls: [],
+*   citations: [],
+*   notes: ['No PII found'],
+* });
+* ```
+*/
+const agentStructuredOutputSchema = z.object({
+	runId: z.string().describe("Unique identifier for the agent run"),
+	summary: z.string().describe("One sentence describing the outcome"),
+	decision: z.string().describe("Final assistant decision or recommendation"),
+	riskLevel: z.enum(riskLevels).describe("Risk classification applied to the run"),
+	toolCalls: z.array(agentToolCallSchema).describe("Every tool call executed during the run"),
+	citations: z.array(agentCitationSchema).describe("Supporting evidence for the decision"),
+	notes: z.array(z.string()).optional().describe("Additional compliance notes captured during the run"),
+	tags: z.array(z.string()).optional().describe("Arbitrary labels for audit filtering")
+});
+
+//#endregion
+export { agentStructuredOutputSchema as n, agentToolCallSchema as r, agentCitationSchema as t };
+//# sourceMappingURL=schemas-SwCsnT0z.mjs.map

package/dist/schemas-SwCsnT0z.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-SwCsnT0z.mjs","names":[],"sources":["../src/agents/base/schemas.ts"],"sourcesContent":["/**\n * @fileoverview Agent output schemas — structured output, tool calls, citations.\n *\n * Defines the standard output format for agent runs including decisions,\n * tool call records, and supporting evidence.\n *\n * @module @od-oneapp/ai-platform/agents/base/schemas\n */\n\nimport { z } from 'zod';\n\nimport { riskLevels } from '../../governance/compliance/schemas';\nexport type { RiskLevel } from '../../governance/compliance/schemas';\n\n/**\n * Schema for agent tool call information.\n * Captures tool execution details for audit and compliance purposes.\n * @example\n * ```ts\n * const call = agentToolCallSchema.parse({\n *   id: 'tool-1',\n *   toolName: 'auditLog',\n *   input: { runId: '123' },\n *   approved: true,\n * });\n * ```\n */\nexport const agentToolCallSchema = z.object({\n  /** Stable identifier for the tool call. */\n  id: z.string().describe('Stable identifier for the tool call'),\n  /** Name of the tool that executed. */\n  toolName: z.string().describe('Name of the tool that executed'),\n  /** Raw input passed to the tool. */\n  input: z\n    .unknown()\n    .refine(val => val !== undefined, {\n      message: 'input is required',\n    })\n    .describe('Raw input passed to the tool'),\n  /** Whether a human approved execution. */\n  approved: z.boolean().optional().describe('Whether a human approved execution'),\n  /** Execution duration in milliseconds. */\n  durationMs: z.number().nonnegative().optional().describe('Execution duration in milliseconds'),\n  /** Short, human readable summary of the tool output. */\n  resultSummary: z.string().optional().describe('Short, human readable summary of the tool output'),\n});\n\n/**\n * Schema for agent citation/reference information.\n * Represents supporting evidence or sources for agent decisions.\n * @example\n * ```ts\n * const citation = agentCitationSchema.parse({\n *   id: 'c1',\n *   title: 'Policy',\n *   url: 'https://example.com',\n *   snippet: 'Policy snippet',\n * });\n * ```\n */\nexport const agentCitationSchema = z.object({\n  /** Citation identifier. */\n  id: z.string(),\n  /** Citation title. */\n  title: z.string(),\n  /** Optional citation URL. */\n  url: z.string().url().optional(),\n  /** Citation snippet/text. */\n  snippet: z.string(),\n  /** Optional relevance score (0-1). */\n  score: z.number().min(0).max(1).optional(),\n});\n\n/**\n * Schema for agent structured output.\n * Comprehensive output format capturing all agent decisions, tool calls, and evidence.\n * @example\n * ```ts\n * const output = agentStructuredOutputSchema.parse({\n *   runId: 'run-1',\n *   summary: 'Completed review',\n *   decision: 'approve',\n *   riskLevel: 'medium',\n *   toolCalls: [],\n *   citations: [],\n *   notes: ['No PII found'],\n * });\n * ```\n */\nexport const agentStructuredOutputSchema = z.object({\n  /** Unique identifier for the agent run. */\n  runId: z.string().describe('Unique identifier for the agent run'),\n  /** One sentence describing the outcome. */\n  summary: z.string().describe('One sentence describing the outcome'),\n  /** Final assistant decision or recommendation. */\n  decision: z.string().describe('Final assistant decision or recommendation'),\n  /** Risk classification applied to the run. */\n  riskLevel: z.enum(riskLevels).describe('Risk classification applied to the run'),\n  /** Every tool call executed during the run. */\n  toolCalls: z.array(agentToolCallSchema).describe('Every tool call executed during the run'),\n  /** Supporting evidence for the decision. */\n  citations: z.array(agentCitationSchema).describe('Supporting evidence for the decision'),\n  /** Additional compliance notes captured during the run. */\n  notes: z\n    .array(z.string())\n    .optional()\n    .describe('Additional compliance notes captured during the run'),\n  /** Arbitrary labels for audit filtering. */\n  tags: z.array(z.string()).optional().describe('Arbitrary labels for audit filtering'),\n});\n\n/** Agent structured output type. */\nexport type AgentStructuredOutput = z.infer<typeof agentStructuredOutputSchema>;\n/** Agent tool call type. */\nexport type AgentToolCall = z.infer<typeof agentToolCallSchema>;\n/** Agent citation type. */\nexport type AgentCitation = z.infer<typeof agentCitationSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,MAAa,sBAAsB,EAAE,OAAO;CAE1C,IAAI,EAAE,QAAQ,CAAC,SAAS,sCAAsC;CAE9D,UAAU,EAAE,QAAQ,CAAC,SAAS,iCAAiC;CAE/D,OAAO,EACJ,SAAS,CACT,QAAO,QAAO,QAAQ,QAAW,EAChC,SAAS,qBACV,CAAC,CACD,SAAS,+BAA+B;CAE3C,UAAU,EAAE,SAAS,CAAC,UAAU,CAAC,SAAS,qCAAqC;CAE/E,YAAY,EAAE,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,SAAS,qCAAqC;CAE9F,eAAe,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,mDAAmD;CAClG,CAAC;;;;;;;;;;;;;;AAeF,MAAa,sBAAsB,EAAE,OAAO;CAE1C,IAAI,EAAE,QAAQ;CAEd,OAAO,EAAE,QAAQ;CAEjB,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;CAEhC,SAAS,EAAE,QAAQ;CAEnB,OAAO,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,UAAU;CAC3C,CAAC;;;;;;;;;;;;;;;;;AAkBF,MAAa,8BAA8B,EAAE,OAAO;CAElD,OAAO,EAAE,QAAQ,CAAC,SAAS,sCAAsC;CAEjE,SAAS,EAAE,QAAQ,CAAC,SAAS,sCAAsC;CAEnE,UAAU,EAAE,QAAQ,CAAC,SAAS,6CAA6C;CAE3E,WAAW,EAAE,KAAK,WAAW,CAAC,SAAS,yCAAyC;CAEhF,WAAW,EAAE,MAAM,oBAAoB,CAAC,SAAS,0CAA0C;CAE3F,WAAW,EAAE,MAAM,oBAAoB,CAAC,SAAS,uCAAuC;CAExF,OAAO,EACJ,MAAM,EAAE,QAAQ,CAAC,CACjB,UAAU,CACV,SAAS,sDAAsD;CAElE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU,CAAC,SAAS,uCAAuC;CACtF,CAAC"}

package/dist/sdk-errors.d.mts

@@ -0,0 +1,2 @@
+import { a as isRetryableError, c as CircuitOpenError, d as PlatformAIError, f as PromptInjectionError, h as ValidationError, i as isPlatformError, l as GuardrailError, m as TenantQuotaError, n as createErrorHandler, o as wrapError, p as RateLimitError, r as getRetryDelay, s as BudgetExceededError, t as AggregateAIError, u as ModelUnavailableError } from "./utils-DpJGOb3y.mjs";
+export { AggregateAIError, BudgetExceededError, CircuitOpenError, GuardrailError, ModelUnavailableError, PlatformAIError, PromptInjectionError, RateLimitError, TenantQuotaError, ValidationError, createErrorHandler, getRetryDelay, isPlatformError, isRetryableError, wrapError };

package/dist/sdk-errors.mjs

@@ -0,0 +1,3 @@
+import { a as isRetryableError, c as CircuitOpenError, d as PlatformAIError, f as PromptInjectionError, h as ValidationError, i as isPlatformError, l as GuardrailError, m as TenantQuotaError, n as createErrorHandler, o as wrapError, p as RateLimitError, r as getRetryDelay, s as BudgetExceededError, t as AggregateAIError, u as ModelUnavailableError } from "./utils-BlYhcD6M.mjs";
+
+export { AggregateAIError, BudgetExceededError, CircuitOpenError, GuardrailError, ModelUnavailableError, PlatformAIError, PromptInjectionError, RateLimitError, TenantQuotaError, ValidationError, createErrorHandler, getRetryDelay, isPlatformError, isRetryableError, wrapError };

package/dist/sdk-experimental.d.mts

@@ -0,0 +1,59 @@
+import { Ur as SDKLanguageModelV3Middleware } from "./ai-runtime-DIwOEc6g.mjs";
+import "./shared.mjs";
+
+//#region src/sdk/experimental/index.d.ts
+declare const experimental_Output: {
+  object<T>(options: {
+    schema: T;
+    description?: string;
+  }): {
+    type: "object";
+    schema: T;
+    description?: string;
+  };
+  array<T>(options: {
+    items: T;
+    description?: string;
+  }): {
+    type: "array";
+    items: T;
+    description?: string;
+  };
+  enum<T extends readonly string[]>(values: T, description?: string): {
+    type: "enum";
+    values: T;
+    description?: string;
+  };
+};
+declare function experimental_composeMiddleware(middlewares: SDKLanguageModelV3Middleware[]): SDKLanguageModelV3Middleware;
+declare function experimental_withSpan<T>(name: string, fn: (span: ExperimentalSpan) => Promise<T>, options?: {
+  attributes?: Record<string, string | number | boolean>;
+}): Promise<T>;
+declare class ExperimentalSpan {
+  readonly name: string;
+  private attributes;
+  private startTime;
+  private endTime?;
+  private status?;
+  constructor(name: string, initialAttributes?: Record<string, string | number | boolean>);
+  setAttribute(key: string, value: string | number | boolean): void;
+  end(status: 'ok' | 'error'): void;
+  getDuration(): number;
+  toJSON(): Record<string, unknown>;
+}
+declare function experimental_retry<T>(fn: () => Promise<T>, options?: {
+  maxRetries?: number;
+  baseDelay?: number;
+  maxDelay?: number;
+  shouldRetry?: (error: unknown, attempt: number) => boolean;
+}): Promise<T>;
+declare function experimental_transformAssistantMessage(transform: (message: {
+  role: 'assistant';
+  content: string;
+}) => {
+  role: 'assistant';
+  content: string;
+}): SDKLanguageModelV3Middleware;
+//#endregion
+export { experimental_Output, experimental_composeMiddleware, experimental_retry, experimental_transformAssistantMessage, experimental_withSpan };
+//# sourceMappingURL=sdk-experimental.d.mts.map

package/dist/sdk-experimental.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-experimental.d.mts","names":[],"sources":["../src/sdk/experimental/index.ts"],"mappings":";;;;cAiBa,mBAAA;YAIH,OAAA;IAAa,MAAA,EAAQ,CAAA;IAAG,WAAA;EAAA;IAC9B,IAAA;IACA,MAAA,EAAQ,CAAA;IACR,WAAA;EAAA;WAYK,OAAA;IAAa,KAAA,EAAO,CAAA;IAAG,WAAA;EAAA;IAC5B,IAAA;IACA,KAAA,EAAO,CAAA;IACP,WAAA;EAAA;oCAY8B,MAAA,EACtB,CAAA,EAAC,WAAA;IAEN,IAAA;IAAc,MAAA,EAAQ,CAAA;IAAG,WAAA;EAAA;AAAA;AAAA,iBAuBhB,8BAAA,CACd,WAAA,EAAa,4BAAA,KACZ,4BAAA;AAAA,iBAuDmB,qBAAA,GAAA,CACpB,IAAA,UACA,EAAA,GAAK,IAAA,EAAM,gBAAA,KAAqB,OAAA,CAAQ,CAAA,GACxC,OAAA;EAAW,UAAA,GAAa,MAAA;AAAA,IACvB,OAAA,CAAQ,CAAA;AAAA,cAgBL,gBAAA;EAAA,SAOO,IAAA;EAAA,QANH,UAAA;EAAA,QACA,SAAA;EAAA,QACA,OAAA;EAAA,QACA,MAAA;cAGG,IAAA,UACT,iBAAA,GAAoB,MAAA;EAOtB,YAAA,CAAa,GAAA,UAAa,KAAA;EAI1B,GAAA,CAAI,MAAA;EAKJ,WAAA,CAAA;EAIA,MAAA,CAAA,GAAU,MAAA;AAAA;AAAA,iBAyBU,kBAAA,GAAA,CACpB,EAAA,QAAU,OAAA,CAAQ,CAAA,GAClB,OAAA;EACE,UAAA;EACA,SAAA;EACA,QAAA;EACA,WAAA,IAAe,KAAA,WAAgB,OAAA;AAAA,IAEhC,OAAA,CAAQ,CAAA;AAAA,iBA8BK,sCAAA,CACd,SAAA,GAAY,OAAA;EAAW,IAAA;EAAmB,OAAA;AAAA;EACxC,IAAA;EACA,OAAA;AAAA,IAED,4BAAA"}

package/dist/sdk-experimental.mjs

@@ -0,0 +1,193 @@
+//#region src/sdk/experimental/index.ts
+/**
+* Experimental: Output structure helpers
+*
+* Provides utilities for working with structured outputs
+*/
+const experimental_Output = {
+	object(options) {
+		return {
+			type: "object",
+			schema: options.schema,
+			description: options.description
+		};
+	},
+	array(options) {
+		return {
+			type: "array",
+			items: options.items,
+			description: options.description
+		};
+	},
+	enum(values, description) {
+		return {
+			type: "enum",
+			values,
+			description
+		};
+	}
+};
+/**
+* Experimental: Compose multiple middlewares
+*
+* @example
+* ```ts
+* import { experimental_composeMiddleware } from "@od-oneapp/ai-platform";
+*
+* const combined = experimental_composeMiddleware([
+*   cachingMiddleware,
+*   loggingMiddleware,
+*   rateLimitMiddleware,
+* ]);
+* ```
+*/
+function experimental_composeMiddleware(middlewares) {
+	return {
+		specificationVersion: "v3",
+		wrapGenerate: async (options) => {
+			let wrappedGenerate = options.doGenerate;
+			for (const middleware of [...middlewares].reverse()) if (middleware.wrapGenerate) {
+				const currentWrapped = wrappedGenerate;
+				const currentMiddleware = middleware.wrapGenerate;
+				wrappedGenerate = () => currentMiddleware({
+					...options,
+					doGenerate: currentWrapped
+				});
+			}
+			return wrappedGenerate();
+		},
+		wrapStream: async (options) => {
+			let wrappedStream = options.doStream;
+			for (const middleware of [...middlewares].reverse()) if (middleware.wrapStream) {
+				const currentWrapped = wrappedStream;
+				const currentMiddleware = middleware.wrapStream;
+				wrappedStream = () => currentMiddleware({
+					...options,
+					doStream: currentWrapped
+				});
+			}
+			return wrappedStream();
+		}
+	};
+}
+/**
+* Experimental: Create a telemetry span wrapper
+*
+* @example
+* ```ts
+* import { experimental_withSpan } from "@od-oneapp/ai-platform";
+*
+* const result = await experimental_withSpan("my-operation", async (span) => {
+*   span.setAttribute("model", "gpt-4");
+*   return await generateText({ ... });
+* });
+* ```
+*/
+async function experimental_withSpan(name, fn, options = {}) {
+	const span = new ExperimentalSpan(name, options.attributes);
+	try {
+		const result = await fn(span);
+		span.end("ok");
+		return result;
+	} catch (error) {
+		span.end("error");
+		throw error;
+	}
+}
+/**
+* Experimental span for telemetry
+*/
+var ExperimentalSpan = class {
+	attributes = {};
+	startTime = Date.now();
+	endTime;
+	status;
+	constructor(name, initialAttributes) {
+		this.name = name;
+		if (initialAttributes) this.attributes = { ...initialAttributes };
+	}
+	setAttribute(key, value) {
+		this.attributes[key] = value;
+	}
+	end(status) {
+		this.endTime = Date.now();
+		this.status = status;
+	}
+	getDuration() {
+		return (this.endTime || Date.now()) - this.startTime;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			attributes: this.attributes,
+			startTime: this.startTime,
+			endTime: this.endTime,
+			duration: this.getDuration(),
+			status: this.status
+		};
+	}
+};
+/**
+* Experimental: Create a retry wrapper with exponential backoff
+*
+* @example
+* ```ts
+* import { experimental_retry } from "@od-oneapp/ai-platform";
+*
+* const result = await experimental_retry(
+*   () => generateText({ ... }),
+*   { maxRetries: 3, baseDelay: 1000 }
+* );
+* ```
+*/
+async function experimental_retry(fn, options = {}) {
+	const { maxRetries = 3, baseDelay = 1e3, maxDelay = 3e4, shouldRetry = () => true } = options;
+	let lastError;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		lastError = error;
+		if (attempt === maxRetries || !shouldRetry(error, attempt)) throw error;
+		await sleep(Math.min(baseDelay * Math.pow(2, attempt), maxDelay));
+	}
+	throw lastError;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Experimental: Transform assistant messages with custom logic
+*/
+function experimental_transformAssistantMessage(transform) {
+	const isTextPart = (value) => {
+		return typeof value === "object" && value !== null && "type" in value && value.type === "text" && "text" in value && typeof value.text === "string";
+	};
+	return {
+		specificationVersion: "v3",
+		wrapGenerate: async ({ doGenerate }) => {
+			const result = await doGenerate();
+			if (Array.isArray(result.content)) {
+				const content = result.content.map((part) => {
+					if (!isTextPart(part)) return part;
+					const transformed = transform({
+						role: "assistant",
+						content: part.text
+					});
+					return {
+						...part,
+						text: transformed.content
+					};
+				});
+				return {
+					...result,
+					content
+				};
+			}
+			return result;
+		}
+	};
+}
+
+//#endregion
+export { experimental_Output, experimental_composeMiddleware, experimental_retry, experimental_transformAssistantMessage, experimental_withSpan };
+//# sourceMappingURL=sdk-experimental.mjs.map

package/dist/sdk-experimental.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-experimental.mjs","names":[],"sources":["../src/sdk/experimental/index.ts"],"sourcesContent":["/**\n * Experimental features module\n *\n * Features in this module use the experimental_ prefix convention\n * from Vercel AI SDK to indicate they may change in future versions.\n *\n * @module @od-oneapp/ai-platform/sdk/experimental\n */\n\nimport type { SDKLanguageModelV3Middleware } from '../../shared';\nimport type { WrapGenerateArgs, WrapStreamArgs } from '../middleware/model-middleware';\n\n/**\n * Experimental: Output structure helpers\n *\n * Provides utilities for working with structured outputs\n */\nexport const experimental_Output = {\n  /**\n   * Create an object output schema\n   */\n  object<T>(options: { schema: T; description?: string }): {\n    type: 'object';\n    schema: T;\n    description?: string;\n  } {\n    return {\n      type: 'object',\n      schema: options.schema,\n      description: options.description,\n    };\n  },\n\n  /**\n   * Create an array output schema\n   */\n  array<T>(options: { items: T; description?: string }): {\n    type: 'array';\n    items: T;\n    description?: string;\n  } {\n    return {\n      type: 'array',\n      items: options.items,\n      description: options.description,\n    };\n  },\n\n  /**\n   * Create an enum output schema\n   */\n  enum<T extends readonly string[]>(\n    values: T,\n    description?: string,\n  ): { type: 'enum'; values: T; description?: string } {\n    return {\n      type: 'enum',\n      values,\n      description,\n    };\n  },\n};\n\n/**\n * Experimental: Compose multiple middlewares\n *\n * @example\n * ```ts\n * import { experimental_composeMiddleware } from \"@od-oneapp/ai-platform\";\n *\n * const combined = experimental_composeMiddleware([\n *   cachingMiddleware,\n *   loggingMiddleware,\n *   rateLimitMiddleware,\n * ]);\n * ```\n */\nexport function experimental_composeMiddleware(\n  middlewares: SDKLanguageModelV3Middleware[],\n): SDKLanguageModelV3Middleware {\n  return {\n    specificationVersion: 'v3',\n    wrapGenerate: async (options: WrapGenerateArgs) => {\n      let wrappedGenerate = options.doGenerate;\n\n      // Apply middlewares in reverse order so first middleware runs first\n      for (const middleware of [...middlewares].reverse()) {\n        if (middleware.wrapGenerate) {\n          const currentWrapped = wrappedGenerate;\n          const currentMiddleware = middleware.wrapGenerate;\n          wrappedGenerate = () =>\n            currentMiddleware({\n              ...options,\n              doGenerate: currentWrapped,\n            });\n        }\n      }\n\n      return wrappedGenerate();\n    },\n\n    wrapStream: async (options: WrapStreamArgs) => {\n      let wrappedStream = options.doStream;\n\n      for (const middleware of [...middlewares].reverse()) {\n        if (middleware.wrapStream) {\n          const currentWrapped = wrappedStream;\n          const currentMiddleware = middleware.wrapStream;\n          wrappedStream = () =>\n            currentMiddleware({\n              ...options,\n              doStream: currentWrapped,\n            });\n        }\n      }\n\n      return wrappedStream();\n    },\n  };\n}\n\n/**\n * Experimental: Create a telemetry span wrapper\n *\n * @example\n * ```ts\n * import { experimental_withSpan } from \"@od-oneapp/ai-platform\";\n *\n * const result = await experimental_withSpan(\"my-operation\", async (span) => {\n *   span.setAttribute(\"model\", \"gpt-4\");\n *   return await generateText({ ... });\n * });\n * ```\n */\nexport async function experimental_withSpan<T>(\n  name: string,\n  fn: (span: ExperimentalSpan) => Promise<T>,\n  options: { attributes?: Record<string, string | number | boolean> } = {},\n): Promise<T> {\n  const span = new ExperimentalSpan(name, options.attributes);\n\n  try {\n    const result = await fn(span);\n    span.end('ok');\n    return result;\n  } catch (error) {\n    span.end('error');\n    throw error;\n  }\n}\n\n/**\n * Experimental span for telemetry\n */\nclass ExperimentalSpan {\n  private attributes: Record<string, string | number | boolean> = {};\n  private startTime = Date.now();\n  private endTime?: number;\n  private status?: 'ok' | 'error';\n\n  constructor(\n    readonly name: string,\n    initialAttributes?: Record<string, string | number | boolean>,\n  ) {\n    if (initialAttributes) {\n      this.attributes = { ...initialAttributes };\n    }\n  }\n\n  setAttribute(key: string, value: string | number | boolean): void {\n    this.attributes[key] = value;\n  }\n\n  end(status: 'ok' | 'error'): void {\n    this.endTime = Date.now();\n    this.status = status;\n  }\n\n  getDuration(): number {\n    return (this.endTime || Date.now()) - this.startTime;\n  }\n\n  toJSON(): Record<string, unknown> {\n    return {\n      name: this.name,\n      attributes: this.attributes,\n      startTime: this.startTime,\n      endTime: this.endTime,\n      duration: this.getDuration(),\n      status: this.status,\n    };\n  }\n}\n\n/**\n * Experimental: Create a retry wrapper with exponential backoff\n *\n * @example\n * ```ts\n * import { experimental_retry } from \"@od-oneapp/ai-platform\";\n *\n * const result = await experimental_retry(\n *   () => generateText({ ... }),\n *   { maxRetries: 3, baseDelay: 1000 }\n * );\n * ```\n */\nexport async function experimental_retry<T>(\n  fn: () => Promise<T>,\n  options: {\n    maxRetries?: number;\n    baseDelay?: number;\n    maxDelay?: number;\n    shouldRetry?: (error: unknown, attempt: number) => boolean;\n  } = {},\n): Promise<T> {\n  const { maxRetries = 3, baseDelay = 1000, maxDelay = 30000, shouldRetry = () => true } = options;\n\n  let lastError: unknown;\n\n  for (let attempt = 0; attempt <= maxRetries; attempt++) {\n    try {\n      return await fn();\n    } catch (error) {\n      lastError = error;\n\n      if (attempt === maxRetries || !shouldRetry(error, attempt)) {\n        throw error;\n      }\n\n      const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);\n      await sleep(delay);\n    }\n  }\n\n  throw lastError;\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * Experimental: Transform assistant messages with custom logic\n */\nexport function experimental_transformAssistantMessage(\n  transform: (message: { role: 'assistant'; content: string }) => {\n    role: 'assistant';\n    content: string;\n  },\n): SDKLanguageModelV3Middleware {\n  const isTextPart = (value: unknown): value is { type: 'text'; text: string } => {\n    return (\n      typeof value === 'object' &&\n      value !== null &&\n      'type' in value &&\n      (value as { type?: unknown }).type === 'text' &&\n      'text' in value &&\n      typeof (value as { text?: unknown }).text === 'string'\n    );\n  };\n\n  return {\n    specificationVersion: 'v3',\n    wrapGenerate: async ({ doGenerate }: WrapGenerateArgs) => {\n      const result = await doGenerate();\n\n      if (Array.isArray(result.content)) {\n        const content = result.content.map(part => {\n          if (!isTextPart(part)) {\n            return part;\n          }\n          const transformed = transform({\n            role: 'assistant',\n            content: part.text,\n          });\n          return { ...part, text: transformed.content };\n        });\n\n        return { ...result, content };\n      }\n\n      return result;\n    },\n  };\n}\n"],"mappings":";;;;;;AAiBA,MAAa,sBAAsB;CAIjC,OAAU,SAIR;AACA,SAAO;GACL,MAAM;GACN,QAAQ,QAAQ;GAChB,aAAa,QAAQ;GACtB;;CAMH,MAAS,SAIP;AACA,SAAO;GACL,MAAM;GACN,OAAO,QAAQ;GACf,aAAa,QAAQ;GACtB;;CAMH,KACE,QACA,aACmD;AACnD,SAAO;GACL,MAAM;GACN;GACA;GACD;;CAEJ;;;;;;;;;;;;;;;AAgBD,SAAgB,+BACd,aAC8B;AAC9B,QAAO;EACL,sBAAsB;EACtB,cAAc,OAAO,YAA8B;GACjD,IAAI,kBAAkB,QAAQ;AAG9B,QAAK,MAAM,cAAc,CAAC,GAAG,YAAY,CAAC,SAAS,CACjD,KAAI,WAAW,cAAc;IAC3B,MAAM,iBAAiB;IACvB,MAAM,oBAAoB,WAAW;AACrC,4BACE,kBAAkB;KAChB,GAAG;KACH,YAAY;KACb,CAAC;;AAIR,UAAO,iBAAiB;;EAG1B,YAAY,OAAO,YAA4B;GAC7C,IAAI,gBAAgB,QAAQ;AAE5B,QAAK,MAAM,cAAc,CAAC,GAAG,YAAY,CAAC,SAAS,CACjD,KAAI,WAAW,YAAY;IACzB,MAAM,iBAAiB;IACvB,MAAM,oBAAoB,WAAW;AACrC,0BACE,kBAAkB;KAChB,GAAG;KACH,UAAU;KACX,CAAC;;AAIR,UAAO,eAAe;;EAEzB;;;;;;;;;;;;;;;AAgBH,eAAsB,sBACpB,MACA,IACA,UAAsE,EAAE,EAC5D;CACZ,MAAM,OAAO,IAAI,iBAAiB,MAAM,QAAQ,WAAW;AAE3D,KAAI;EACF,MAAM,SAAS,MAAM,GAAG,KAAK;AAC7B,OAAK,IAAI,KAAK;AACd,SAAO;UACA,OAAO;AACd,OAAK,IAAI,QAAQ;AACjB,QAAM;;;;;;AAOV,IAAM,mBAAN,MAAuB;CACrB,AAAQ,aAAwD,EAAE;CAClE,AAAQ,YAAY,KAAK,KAAK;CAC9B,AAAQ;CACR,AAAQ;CAER,YACE,AAAS,MACT,mBACA;EAFS;AAGT,MAAI,kBACF,MAAK,aAAa,EAAE,GAAG,mBAAmB;;CAI9C,aAAa,KAAa,OAAwC;AAChE,OAAK,WAAW,OAAO;;CAGzB,IAAI,QAA8B;AAChC,OAAK,UAAU,KAAK,KAAK;AACzB,OAAK,SAAS;;CAGhB,cAAsB;AACpB,UAAQ,KAAK,WAAW,KAAK,KAAK,IAAI,KAAK;;CAG7C,SAAkC;AAChC,SAAO;GACL,MAAM,KAAK;GACX,YAAY,KAAK;GACjB,WAAW,KAAK;GAChB,SAAS,KAAK;GACd,UAAU,KAAK,aAAa;GAC5B,QAAQ,KAAK;GACd;;;;;;;;;;;;;;;;AAiBL,eAAsB,mBACpB,IACA,UAKI,EAAE,EACM;CACZ,MAAM,EAAE,aAAa,GAAG,YAAY,KAAM,WAAW,KAAO,oBAAoB,SAAS;CAEzF,IAAI;AAEJ,MAAK,IAAI,UAAU,GAAG,WAAW,YAAY,UAC3C,KAAI;AACF,SAAO,MAAM,IAAI;UACV,OAAO;AACd,cAAY;AAEZ,MAAI,YAAY,cAAc,CAAC,YAAY,OAAO,QAAQ,CACxD,OAAM;AAIR,QAAM,MADQ,KAAK,IAAI,YAAY,KAAK,IAAI,GAAG,QAAQ,EAAE,SAAS,CAChD;;AAItB,OAAM;;AAGR,SAAS,MAAM,IAA2B;AACxC,QAAO,IAAI,SAAQ,YAAW,WAAW,SAAS,GAAG,CAAC;;;;;AAMxD,SAAgB,uCACd,WAI8B;CAC9B,MAAM,cAAc,UAA4D;AAC9E,SACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SACT,MAA6B,SAAS,UACvC,UAAU,SACV,OAAQ,MAA6B,SAAS;;AAIlD,QAAO;EACL,sBAAsB;EACtB,cAAc,OAAO,EAAE,iBAAmC;GACxD,MAAM,SAAS,MAAM,YAAY;AAEjC,OAAI,MAAM,QAAQ,OAAO,QAAQ,EAAE;IACjC,MAAM,UAAU,OAAO,QAAQ,KAAI,SAAQ;AACzC,SAAI,CAAC,WAAW,KAAK,CACnB,QAAO;KAET,MAAM,cAAc,UAAU;MAC5B,MAAM;MACN,SAAS,KAAK;MACf,CAAC;AACF,YAAO;MAAE,GAAG;MAAM,MAAM,YAAY;MAAS;MAC7C;AAEF,WAAO;KAAE,GAAG;KAAQ;KAAS;;AAG/B,UAAO;;EAEV"}

package/dist/sdk-stop-conditions.d.mts

@@ -0,0 +1,3 @@
+import "./ai-runtime-DIwOEc6g.mjs";
+import { a as noToolCalls, c as textContains, d as toolResultContains, f as whenMetadata, g as StopConditionResult, h as StopConditionOptions, i as hasToolCall, l as textEndsWith, m as StopConditionContext, n as allOf, o as not, p as StopCondition, r as anyOf, s as stepCountIs, t as afterTimeout, u as textEquals } from "./conditions-zDrKfrc3.mjs";
+export { type StopCondition, type StopConditionContext, type StopConditionOptions, type StopConditionResult, afterTimeout, allOf, anyOf, hasToolCall, noToolCalls, not, stepCountIs, textContains, textEndsWith, textEquals, toolResultContains, whenMetadata };

package/dist/sdk-stop-conditions.mjs

@@ -0,0 +1,3 @@
+import { a as noToolCalls, c as textContains, d as toolResultContains, f as whenMetadata, i as hasToolCall, l as textEndsWith, n as allOf, o as not, r as anyOf, s as stepCountIs, t as afterTimeout, u as textEquals } from "./conditions-DmQ6Y1Wt.mjs";
+
+export { afterTimeout, allOf, anyOf, hasToolCall, noToolCalls, not, stepCountIs, textContains, textEndsWith, textEquals, toolResultContains, whenMetadata };

package/dist/sdk.d.mts

@@ -0,0 +1,15 @@
+import "./ai-runtime-DIwOEc6g.mjs";
+import "./types-BPnq3GQo.mjs";
+import { a as isRetryableError, c as CircuitOpenError, d as PlatformAIError, f as PromptInjectionError, h as ValidationError, i as isPlatformError, l as GuardrailError, m as TenantQuotaError, n as createErrorHandler, o as wrapError, p as RateLimitError, r as getRetryDelay, s as BudgetExceededError, t as AggregateAIError, u as ModelUnavailableError } from "./utils-DpJGOb3y.mjs";
+import { a as noToolCalls, c as textContains, d as toolResultContains, f as whenMetadata, g as StopConditionResult, h as StopConditionOptions, i as hasToolCall, l as textEndsWith, m as StopConditionContext, n as allOf, o as not, p as StopCondition, r as anyOf, s as stepCountIs, t as afterTimeout, u as textEquals } from "./conditions-zDrKfrc3.mjs";
+import "./sdk-stop-conditions.mjs";
+import { experimental_Output, experimental_composeMiddleware, experimental_retry, experimental_transformAssistantMessage, experimental_withSpan } from "./sdk-experimental.mjs";
+import { a as CircuitBreakerRegistry, i as CircuitBreaker, n as CircuitState, o as circuitBreakerRegistry, r as createCircuitBreaker, s as withCircuitBreaker, t as CircuitBreakerConfig } from "./index-BDwgsK9B.mjs";
+
+//#region src/sdk/index.d.ts
+declare namespace index_d_exports {
+  export { AggregateAIError, BudgetExceededError, CircuitBreaker, CircuitBreakerConfig, CircuitBreakerRegistry, CircuitOpenError, CircuitState, GuardrailError, ModelUnavailableError, PlatformAIError, PromptInjectionError, RateLimitError, StopCondition, StopConditionContext, StopConditionOptions, StopConditionResult, TenantQuotaError, ValidationError, afterTimeout, allOf, anyOf, circuitBreakerRegistry, createCircuitBreaker, createErrorHandler, experimental_Output, experimental_composeMiddleware, experimental_retry, experimental_transformAssistantMessage, experimental_withSpan, getRetryDelay, hasToolCall, isPlatformError, isRetryableError, noToolCalls, not, stepCountIs, textContains, textEndsWith, textEquals, toolResultContains, whenMetadata, withCircuitBreaker, wrapError };
+}
+//#endregion
+export { AggregateAIError, BudgetExceededError, CircuitBreaker, type CircuitBreakerConfig, CircuitBreakerRegistry, CircuitOpenError, type CircuitState, GuardrailError, ModelUnavailableError, PlatformAIError, PromptInjectionError, RateLimitError, StopCondition, StopConditionContext, StopConditionOptions, StopConditionResult, TenantQuotaError, ValidationError, afterTimeout, allOf, anyOf, circuitBreakerRegistry, createCircuitBreaker, createErrorHandler, experimental_Output, experimental_composeMiddleware, experimental_retry, experimental_transformAssistantMessage, experimental_withSpan, getRetryDelay, hasToolCall, isPlatformError, isRetryableError, noToolCalls, not, stepCountIs, index_d_exports as t, textContains, textEndsWith, textEquals, toolResultContains, whenMetadata, withCircuitBreaker, wrapError };
+//# sourceMappingURL=sdk.d.mts.map

package/dist/sdk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../src/sdk/index.ts"],"mappings":""}

package/dist/sdk.mjs

@@ -0,0 +1,50 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { a as isRetryableError, c as CircuitOpenError, d as PlatformAIError, f as PromptInjectionError, h as ValidationError, i as isPlatformError, l as GuardrailError, m as TenantQuotaError, n as createErrorHandler, o as wrapError, p as RateLimitError, r as getRetryDelay, s as BudgetExceededError, t as AggregateAIError, u as ModelUnavailableError } from "./utils-BlYhcD6M.mjs";
+import { a as noToolCalls, c as textContains, d as toolResultContains, f as whenMetadata, i as hasToolCall, l as textEndsWith, n as allOf, o as not, r as anyOf, s as stepCountIs, t as afterTimeout, u as textEquals } from "./conditions-DmQ6Y1Wt.mjs";
+import { experimental_Output, experimental_composeMiddleware, experimental_retry, experimental_transformAssistantMessage, experimental_withSpan } from "./sdk-experimental.mjs";
+import { a as withCircuitBreaker, i as circuitBreakerRegistry, n as CircuitBreaker, r as CircuitBreakerRegistry, t as createCircuitBreaker } from "./middleware-CZQCTHfl.mjs";
+
+//#region src/sdk/index.ts
+var sdk_exports = /* @__PURE__ */ __exportAll({
+	AggregateAIError: () => AggregateAIError,
+	BudgetExceededError: () => BudgetExceededError,
+	CircuitBreaker: () => CircuitBreaker,
+	CircuitBreakerRegistry: () => CircuitBreakerRegistry,
+	CircuitOpenError: () => CircuitOpenError,
+	GuardrailError: () => GuardrailError,
+	ModelUnavailableError: () => ModelUnavailableError,
+	PlatformAIError: () => PlatformAIError,
+	PromptInjectionError: () => PromptInjectionError,
+	RateLimitError: () => RateLimitError,
+	TenantQuotaError: () => TenantQuotaError,
+	ValidationError: () => ValidationError,
+	afterTimeout: () => afterTimeout,
+	allOf: () => allOf,
+	anyOf: () => anyOf,
+	circuitBreakerRegistry: () => circuitBreakerRegistry,
+	createCircuitBreaker: () => createCircuitBreaker,
+	createErrorHandler: () => createErrorHandler,
+	experimental_Output: () => experimental_Output,
+	experimental_composeMiddleware: () => experimental_composeMiddleware,
+	experimental_retry: () => experimental_retry,
+	experimental_transformAssistantMessage: () => experimental_transformAssistantMessage,
+	experimental_withSpan: () => experimental_withSpan,
+	getRetryDelay: () => getRetryDelay,
+	hasToolCall: () => hasToolCall,
+	isPlatformError: () => isPlatformError,
+	isRetryableError: () => isRetryableError,
+	noToolCalls: () => noToolCalls,
+	not: () => not,
+	stepCountIs: () => stepCountIs,
+	textContains: () => textContains,
+	textEndsWith: () => textEndsWith,
+	textEquals: () => textEquals,
+	toolResultContains: () => toolResultContains,
+	whenMetadata: () => whenMetadata,
+	withCircuitBreaker: () => withCircuitBreaker,
+	wrapError: () => wrapError
+});
+
+//#endregion
+export { AggregateAIError, BudgetExceededError, CircuitBreaker, CircuitBreakerRegistry, CircuitOpenError, GuardrailError, ModelUnavailableError, PlatformAIError, PromptInjectionError, RateLimitError, TenantQuotaError, ValidationError, afterTimeout, allOf, anyOf, circuitBreakerRegistry, createCircuitBreaker, createErrorHandler, experimental_Output, experimental_composeMiddleware, experimental_retry, experimental_transformAssistantMessage, experimental_withSpan, getRetryDelay, hasToolCall, isPlatformError, isRetryableError, noToolCalls, not, stepCountIs, sdk_exports as t, textContains, textEndsWith, textEquals, toolResultContains, whenMetadata, withCircuitBreaker, wrapError };
+//# sourceMappingURL=sdk.mjs.map