@abot-ai/runtime 1.0.0

package/dist/src/model-gateway/structured-output/openai-format.js

@@ -0,0 +1,75 @@
+import { isModelGatewayJsonSchemaFormat, isPlainObject, rejectMisplacedProjectionMetadata, } from "./format-contract.js";
+const OPENAI_GENERIC_SCHEMA_NAME = "runtime_structured_output";
+function hasUnsupportedRootUnion(schema) {
+    return (Array.isArray(schema.oneOf) ||
+        Array.isArray(schema.anyOf) ||
+        Array.isArray(schema.allOf));
+}
+function emptyProjection(format) {
+    return {
+        format,
+        instructions: Object.freeze([]),
+        diagnostics: Object.freeze([]),
+    };
+}
+function standardJsonSchemaFormat(format) {
+    return {
+        type: "json_schema",
+        name: format.name,
+        schema: format.schema,
+        ...(format.description === undefined
+            ? {}
+            : { description: format.description }),
+        ...(format.strict === undefined ? {} : { strict: format.strict }),
+    };
+}
+function rootUnionFallback(schemaName, schema) {
+    const instruction = [
+        `The required response contract is the JSON Schema named ${JSON.stringify(schemaName)} below.`,
+        "The provider is using JSON mode because the schema has a root union.",
+        "Return exactly one JSON object matching exactly one schema variant.",
+        "Use only fields declared by that selected variant. Do not rename fields or add wrapper, discriminator, response, or schema metadata fields unless the selected variant explicitly declares them.",
+        `JSON Schema: ${JSON.stringify(schema)}`,
+    ].join("\n");
+    return {
+        format: { type: "json_object" },
+        instructions: Object.freeze([instruction]),
+        diagnostics: Object.freeze([
+            {
+                action: "schema_instruction_injected",
+                schemaName,
+                reason: "openai_root_union_unsupported",
+                instructionCharacterCount: instruction.length,
+            },
+        ]),
+    };
+}
+export function projectOpenAIResponsesFormat(format) {
+    if (format === "json") {
+        return emptyProjection({ type: "json_object" });
+    }
+    if (!isPlainObject(format)) {
+        return emptyProjection(undefined);
+    }
+    if (isModelGatewayJsonSchemaFormat(format)) {
+        return hasUnsupportedRootUnion(format.schema)
+            ? rootUnionFallback(format.name, format.schema)
+            : emptyProjection(standardJsonSchemaFormat(format));
+    }
+    if (format.type === "json_object") {
+        rejectMisplacedProjectionMetadata(format);
+        return emptyProjection({ type: "json_object" });
+    }
+    rejectMisplacedProjectionMetadata(format);
+    if (hasUnsupportedRootUnion(format)) {
+        return rootUnionFallback(OPENAI_GENERIC_SCHEMA_NAME, format);
+    }
+    return emptyProjection({
+        type: "json_schema",
+        name: OPENAI_GENERIC_SCHEMA_NAME,
+        schema: format,
+    });
+}
+export function toOpenAIResponsesTextFormat(format) {
+    return projectOpenAIResponsesFormat(format).format;
+}

package/dist/src/model-gateway/structured-output/projection.d.ts

@@ -0,0 +1,3 @@
+export { isModelGatewayJsonSchemaFormat, resolveModelGatewayFormat, } from "./format-contract.js";
+export { projectOllamaFormat, toOllamaFormat, type OllamaFormatProjection, type OllamaSchemaProjectionDiagnostic, } from "./ollama-format.js";
+export { projectOpenAIResponsesFormat, toOpenAIResponsesTextFormat, type OpenAIFormatProjection, type OpenAISchemaProjectionDiagnostic, } from "./openai-format.js";

package/dist/src/model-gateway/structured-output/projection.js

@@ -0,0 +1,3 @@
+export { isModelGatewayJsonSchemaFormat, resolveModelGatewayFormat, } from "./format-contract.js";
+export { projectOllamaFormat, toOllamaFormat, } from "./ollama-format.js";
+export { projectOpenAIResponsesFormat, toOpenAIResponsesTextFormat, } from "./openai-format.js";

package/dist/src/model-gateway/structured-output/schema-character-estimator.d.ts

@@ -0,0 +1 @@
+export declare function estimateStrictSchemaCharacters(schema: Readonly<Record<string, unknown>>): number | undefined;

package/dist/src/model-gateway/structured-output/schema-character-estimator.js

@@ -0,0 +1,211 @@
+const MAX_SCHEMA_DEPTH = 32;
+const MAX_SCHEMA_VISITS = 50_000;
+const MAX_SERIALIZED_NUMBER_CHARACTERS = Math.max(JSON.stringify(Number.MAX_VALUE).length, JSON.stringify(-Number.MAX_VALUE).length, JSON.stringify(Number.MIN_VALUE).length, JSON.stringify(-Number.MIN_VALUE).length);
+export function estimateStrictSchemaCharacters(schema) {
+    return estimateSchemaNodeCharacters(schema, 0, {
+        visits: 0,
+    });
+}
+function estimateSchemaNodeCharacters(schema, depth, state) {
+    state.visits += 1;
+    if (depth > MAX_SCHEMA_DEPTH || state.visits > MAX_SCHEMA_VISITS) {
+        return undefined;
+    }
+    const bounds = [];
+    const constantBound = estimateExactJsonCharacters(schema.const);
+    if (Object.hasOwn(schema, "const") && constantBound !== undefined) {
+        bounds.push(constantBound);
+    }
+    const enumBound = estimateEnumCharacters(schema.enum);
+    if (enumBound !== undefined) {
+        bounds.push(enumBound);
+    }
+    const typeBound = estimateDeclaredTypeCharacters(schema, depth, state);
+    if (typeBound !== undefined) {
+        bounds.push(typeBound);
+    }
+    for (const union of [schema.anyOf, schema.oneOf]) {
+        const unionBound = estimateUnionCharacters(union, depth, state);
+        if (unionBound !== undefined) {
+            bounds.push(unionBound);
+        }
+    }
+    const intersectionBound = estimateIntersectionCharacters(schema.allOf, depth, state);
+    if (intersectionBound !== undefined) {
+        bounds.push(intersectionBound);
+    }
+    return bounds.length > 0 ? minimum(bounds) : undefined;
+}
+function estimateDeclaredTypeCharacters(schema, depth, state) {
+    const types = readDeclaredTypes(schema);
+    if (types.length === 0) {
+        return undefined;
+    }
+    const bounds = types.map((type) => estimateTypeCharacters(type, schema, depth, state));
+    return bounds.every((bound) => bound !== undefined)
+        ? maximum(bounds)
+        : undefined;
+}
+function readDeclaredTypes(schema) {
+    if (Array.isArray(schema.type)) {
+        return schema.type.filter((value) => typeof value === "string");
+    }
+    if (typeof schema.type === "string") {
+        return [schema.type];
+    }
+    return inferStructuralType(schema);
+}
+function inferStructuralType(schema) {
+    if (Object.hasOwn(schema, "properties"))
+        return ["object"];
+    if (Object.hasOwn(schema, "items"))
+        return ["array"];
+    return [];
+}
+function estimateTypeCharacters(type, schema, depth, state) {
+    switch (type) {
+        case "null":
+            return 4;
+        case "boolean":
+            return 5;
+        case "number":
+        case "integer":
+            return MAX_SERIALIZED_NUMBER_CHARACTERS;
+        case "string": {
+            const maxLength = readNonNegativeInteger(schema.maxLength);
+            return maxLength === undefined ? undefined : safeAdd(maxLength, 2);
+        }
+        case "array":
+            return estimateArrayCharacters(schema, depth, state);
+        case "object":
+            return estimateObjectCharacters(schema, depth, state);
+        default:
+            return undefined;
+    }
+}
+function estimateArrayCharacters(schema, depth, state) {
+    const maxItems = readNonNegativeInteger(schema.maxItems);
+    if (maxItems === undefined)
+        return undefined;
+    if (maxItems === 0)
+        return 2;
+    if (isPlainRecord(schema.items)) {
+        const itemCharacters = estimateSchemaNodeCharacters(schema.items, depth + 1, state);
+        return itemCharacters === undefined
+            ? undefined
+            : safeAdd(2, safeAdd(maxItems - 1, safeMultiply(maxItems, itemCharacters)));
+    }
+    if (!Array.isArray(schema.items))
+        return undefined;
+    if (!schema.items.every(isPlainRecord))
+        return undefined;
+    const itemSchemas = schema.items;
+    const effectiveMaxItems = schema.additionalItems === false
+        ? Math.min(maxItems, itemSchemas.length)
+        : maxItems;
+    const fixedItemCount = Math.min(effectiveMaxItems, itemSchemas.length);
+    let characters = safeAdd(2, Math.max(0, effectiveMaxItems - 1));
+    for (let index = 0; index < fixedItemCount; index += 1) {
+        const itemCharacters = estimateSchemaNodeCharacters(itemSchemas[index], depth + 1, state);
+        if (itemCharacters === undefined)
+            return undefined;
+        characters = safeAdd(characters, itemCharacters);
+    }
+    if (effectiveMaxItems <= itemSchemas.length)
+        return characters;
+    if (!isPlainRecord(schema.additionalItems))
+        return undefined;
+    const additionalCharacters = estimateSchemaNodeCharacters(schema.additionalItems, depth + 1, state);
+    return additionalCharacters === undefined
+        ? undefined
+        : safeAdd(characters, safeMultiply(effectiveMaxItems - itemSchemas.length, additionalCharacters));
+}
+function estimateObjectCharacters(schema, depth, state) {
+    const hasPatternProperties = isPlainRecord(schema.patternProperties) &&
+        Object.keys(schema.patternProperties).length > 0;
+    const allowsUnboundedProperties = schema.additionalProperties !== false;
+    if (allowsUnboundedProperties || hasPatternProperties) {
+        return undefined;
+    }
+    if (schema.properties !== undefined && !isPlainRecord(schema.properties)) {
+        return undefined;
+    }
+    const properties = isPlainRecord(schema.properties)
+        ? Object.entries(schema.properties)
+        : [];
+    let characters = safeAdd(2, Math.max(0, properties.length - 1));
+    for (const [property, propertySchema] of properties) {
+        if (!isPlainRecord(propertySchema))
+            return undefined;
+        const valueCharacters = estimateSchemaNodeCharacters(propertySchema, depth + 1, state);
+        if (valueCharacters === undefined)
+            return undefined;
+        characters = safeAdd(characters, safeAdd(JSON.stringify(property).length + 1, valueCharacters));
+    }
+    return characters;
+}
+function estimateUnionCharacters(value, depth, state) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const branches = value.filter(isPlainRecord);
+    if (branches.length !== value.length)
+        return undefined;
+    const bounds = branches.map((branch) => estimateSchemaNodeCharacters(branch, depth + 1, state));
+    return bounds.every((bound) => bound !== undefined)
+        ? maximum(bounds)
+        : undefined;
+}
+function estimateIntersectionCharacters(value, depth, state) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const bounds = value
+        .filter(isPlainRecord)
+        .map((branch) => estimateSchemaNodeCharacters(branch, depth + 1, state))
+        .filter((bound) => bound !== undefined);
+    return bounds.length > 0 ? minimum(bounds) : undefined;
+}
+function estimateEnumCharacters(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const bounds = value.map(estimateExactJsonCharacters);
+    return bounds.every((bound) => bound !== undefined)
+        ? maximum(bounds)
+        : undefined;
+}
+function estimateExactJsonCharacters(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        return typeof serialized === "string" ? serialized.length : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : undefined;
+}
+function isPlainRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function safeAdd(left, right) {
+    return Math.min(Number.MAX_SAFE_INTEGER, left + right);
+}
+function safeMultiply(left, right) {
+    if (left === 0 || right === 0)
+        return 0;
+    return left > Number.MAX_SAFE_INTEGER / right
+        ? Number.MAX_SAFE_INTEGER
+        : left * right;
+}
+function minimum(values) {
+    return values.reduce((result, value) => Math.min(result, value));
+}
+function maximum(values) {
+    return values.reduce((result, value) => Math.max(result, value));
+}

package/dist/src/model-gateway/structured-output-budget.d.ts

@@ -0,0 +1 @@
+export * from "./structured-output/budget.js";

package/dist/src/model-gateway/structured-output-budget.js

@@ -0,0 +1 @@
+export * from "./structured-output/budget.js";

package/dist/src/model-gateway/structured-output.d.ts

@@ -0,0 +1 @@
+export * from "./structured-output/projection.js";

package/dist/src/model-gateway/structured-output.js

@@ -0,0 +1 @@
+export * from "./structured-output/projection.js";

package/dist/src/model-gateway/types.d.ts

@@ -0,0 +1,214 @@
+import type { AgentMode, ModelReasoningLevel, ModelStep } from "../shared/types.js";
+import type { RuntimeAttachmentReference } from "../shared/attachments.js";
+/** Stable adapter identifier. Built-ins currently register `ollama` and `openai`. */
+export type ModelProvider = string;
+export type ChatTextMessage = {
+    role: "system" | "user" | "assistant";
+    content: string;
+    attachments?: ModelGatewayAttachment[];
+    toolCalls?: never;
+};
+export type ModelGatewayToolCall = Readonly<{
+    /** Canonical call identity shared with the matching result. */
+    callId: string;
+    /** Provider-safe function name shared with the matching result. */
+    name: string;
+    /** Exact JSON arguments. Provider projection must not semantically rewrite it. */
+    arguments: string;
+}>;
+export type ChatAssistantToolCallMessage = Readonly<{
+    role: "assistant";
+    /** Tool action JSON lives only in toolCalls[].arguments. */
+    content: "";
+    toolCalls: readonly ModelGatewayToolCall[];
+    attachments?: never;
+}>;
+export type ChatToolResultMessage = Readonly<{
+    role: "tool";
+    /** Exact output from the mechanically linked call. */
+    content: string;
+    toolCallId: string;
+    toolName: string;
+    attachments?: never;
+    toolCalls?: never;
+}>;
+export type ChatMessage = ChatTextMessage | ChatAssistantToolCallMessage | ChatToolResultMessage;
+export type ModelGatewayAttachment = RuntimeAttachmentReference & {
+    data?: string;
+};
+export type ModelGatewayJsonSchemaFormat = {
+    type: "json_schema";
+    name: string;
+    schema: Record<string, unknown>;
+    description?: string;
+    strict?: boolean;
+    /**
+     * Exact constraints that the owning parser/runtime enforces after generation.
+     * A provider projector may remove only a listed keyword at the listed JSON
+     * Pointer and must diagnose every removal.
+     */
+    postValidatedSchemaConstraints?: readonly Readonly<{
+        keyword: "maxLength";
+        path: string;
+    }>[];
+};
+export type ModelGatewayFormat = "json" | ModelGatewayJsonSchemaFormat | Record<string, unknown>;
+export type ModelPreferenceScope = "main" | "all";
+export type ModelPreference = {
+    profileId: string;
+    scope?: ModelPreferenceScope;
+};
+export type ModelGatewayProfileConfig = {
+    label?: string;
+    configRef?: string;
+    provider?: string;
+    model: string;
+    /** Declared physical context capacity. Required after profile materialization. */
+    contextWindowTokens?: number;
+    supportsThinking?: boolean;
+    capabilities?: ModelGatewayProfileCapabilities;
+    options?: Record<string, unknown>;
+    generation?: ModelGenerationConfig;
+    context?: ModelContextConfig;
+    calibration?: Record<string, ModelStepCalibrationConfig>;
+};
+export type ModelModality = "text" | "image" | "audio";
+export type ModelGatewayProfileCapabilities = {
+    inputModalities?: ModelModality[];
+    outputModalities?: ModelModality[];
+};
+export type ModelGatewayProviderConfig = {
+    type: ModelProvider;
+    baseUrl?: string;
+    apiKeyEnv?: string;
+    keepAlive?: string;
+    /** Provider-owned JSON configuration outside the shared transport fields. */
+    settings?: Record<string, unknown>;
+};
+export type ModelGenerationConfig = {
+    temperature?: number;
+    topP?: number;
+    reasoningEffort?: ModelReasoningLevel;
+};
+export type ModelTokenEstimationConfig = {
+    asciiCharactersPerToken?: number;
+    nonAsciiBytesPerToken?: number;
+    messageOverheadTokens?: number;
+};
+export type ModelFormatTokenAccountingConfig = {
+    mode: "none" | "estimate";
+    fixedOverheadTokens?: number;
+};
+export type ModelContextConfig = {
+    formatTokenAccounting?: ModelFormatTokenAccountingConfig;
+    tokenEstimation?: ModelTokenEstimationConfig;
+};
+export type ModelGatewayPolicyDefaults = {
+    overrideClientPreference?: boolean;
+    profileId?: string;
+    roles?: Record<string, string>;
+    steps?: Record<string, string>;
+    context?: ModelContextConfig;
+};
+export type ModelInvocationProfileConfig = {
+    profileId: string;
+    generation?: ModelGenerationConfig;
+    context?: ModelContextConfig;
+    format?: ModelGatewayFormat;
+};
+export type ModelStepCalibrationConfig = {
+    profileId?: string;
+    timeoutMs?: number;
+    generation?: ModelGenerationConfig;
+    context?: ModelContextConfig;
+    format?: ModelGatewayFormat;
+    instructions?: string[];
+};
+export type ModelGatewayPolicyConfig = {
+    providers?: Record<string, ModelGatewayProviderConfig>;
+    profiles?: Record<string, ModelGatewayProfileConfig>;
+    invocationProfiles?: Record<string, ModelInvocationProfileConfig>;
+    defaults?: ModelGatewayPolicyDefaults;
+};
+export type ModelGatewayRequest = {
+    text?: string;
+    prompt?: string;
+    messages?: unknown;
+    debugRequestId?: string;
+    agentMode?: AgentMode | string;
+    taskType?: string;
+    modelStep?: ModelStep | string;
+    modelOverride?: string;
+    reasoningOverride?: ModelReasoningLevel | string;
+    format?: unknown;
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+};
+export type ModelGatewayInputTokenCountParams = {
+    /** Local capability hint only; the gateway still resolves and verifies the provider. */
+    provider: ModelProvider;
+    text?: string;
+    messages?: unknown;
+    agentMode: AgentMode;
+    taskType?: string;
+    modelStep?: ModelStep;
+    modelOverride?: string;
+    reasoningOverride?: ModelReasoningLevel;
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    abortSignal: AbortSignal;
+    debugRequestId?: string;
+    format?: "json" | Record<string, unknown>;
+};
+export type ModelGatewayInputTokenCountResult = Readonly<{
+    inputTokens: number;
+    profileId: string;
+    provider: ModelProvider;
+    model: string;
+    contextWindowTokens: number;
+    source: "provider_input_token_count";
+}>;
+export type ModelProfile = {
+    id: string;
+    label: string;
+    providerId: string;
+    provider: ModelProvider;
+    providerConfig?: ModelGatewayProviderConfig;
+    model: string;
+    contextWindowTokens: number;
+    supportsThinking: boolean;
+    capabilities: Required<ModelGatewayProfileCapabilities>;
+    options: Record<string, unknown>;
+    generation: ModelGenerationConfig;
+    context: ModelContextConfig;
+    calibration?: Record<string, ModelStepCalibrationConfig>;
+};
+export type ResolvedModelInvocation = {
+    profile: ModelProfile;
+    model: string;
+    think?: ModelReasoningLevel;
+    format?: ModelGatewayFormat;
+    instructions?: string[];
+};
+export type ModelGatewayEvent = {
+    type: "thinking";
+    text: string;
+} | {
+    type: "content";
+    text: string;
+} | {
+    type: "error";
+    error: string;
+} | {
+    type: "done";
+    done: true;
+    doneReason: string | null;
+    usage?: ModelTokenUsage;
+};
+export type ModelTokenUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens?: number;
+    reasoningTokens?: number;
+};

package/dist/src/model-gateway/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/plugin-contract/entrypoint.d.ts

@@ -0,0 +1,34 @@
+import type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput } from "../capabilities/tool-types.js";
+import type { ToolNormalInvocationContract } from "../capabilities/normal-invocation/contracts.js";
+export type RuntimePluginLoadContext = {
+    id: string;
+    path: string;
+    stateDir: string;
+    rootDir: string;
+    runtimeId: string;
+    agentBridgeUrl: string;
+    runtimePaths: {
+        rootDir: string;
+        runtimeDir: string;
+        agentWorkDir: string;
+        sessionsDir: string;
+        attachmentsDir: string;
+        workspaceDir: string;
+        sharedDir: string;
+        compiledDir: string;
+        traceFile: string;
+    };
+    runtimePathResolver: RuntimeToolPathResolver;
+    config?: Record<string, unknown>;
+    secrets?: Readonly<{
+        get(name: string): string | undefined;
+    }>;
+};
+export type RuntimePluginEntrypoint = Readonly<{
+    handlers: Readonly<Record<string, ToolImplementation>>;
+    adapters?: Readonly<Record<string, ToolCallAdapter>>;
+}>;
+export type RuntimePluginEntrypointFactory = (context: RuntimePluginLoadContext & Readonly<{
+    pluginRoot: string;
+}>) => RuntimePluginEntrypoint;
+export type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput, ToolNormalInvocationContract, };

package/dist/src/plugin-contract/entrypoint.js

@@ -0,0 +1 @@
+export {};

package/dist/src/plugin-contract/index.d.ts

@@ -0,0 +1,2 @@
+export type * from "./entrypoint.js";
+export * from "./manifest.js";

package/dist/src/plugin-contract/index.js

@@ -0,0 +1 @@
+export * from "./manifest.js";

package/dist/src/plugin-contract/manifest.d.ts

@@ -0,0 +1,49 @@
+import type { ToolCatalogGroup, ToolDevelopmentRole, ToolEventPresentation, ToolNormalInvocationApproval, ToolNormalInvocationEffect, ToolNormalInvocationFixedValue, ToolNormalInvocationInput, ToolNormalInvocationPayload, ToolPayloadChannelSpec, ToolRoutingCapability, ToolRuntimePathBinding } from "../capabilities/tool-types.js";
+export declare const AGENT_PLUGIN_MANIFEST_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+export declare const ABOT_RUNTIME_EXTENSION = "ai.abot.runtime";
+export declare const ABOT_RUNTIME_EXTENSION_VERSION: 1;
+export type AgentPluginOperationManifest = Readonly<{
+    summary: string;
+    input: ToolNormalInvocationInput;
+    effect: ToolNormalInvocationEffect;
+    approval: ToolNormalInvocationApproval;
+    fixedParams?: Readonly<Record<string, ToolNormalInvocationFixedValue>>;
+    payload?: ToolNormalInvocationPayload;
+}>;
+export type AgentPluginCapabilityManifest = Readonly<{
+    description: string;
+    routingCapability: ToolRoutingCapability;
+    controlsRefinement?: "mechanical_when_complete";
+    catalogGroups?: readonly ToolCatalogGroup[];
+    skills: readonly string[];
+    developmentRoles?: readonly ToolDevelopmentRole[];
+    eventPresentation?: ToolEventPresentation;
+    payloadChannelSpec?: ToolPayloadChannelSpec;
+    runtimePathBindings?: readonly ToolRuntimePathBinding[];
+    operations: Readonly<Record<string, AgentPluginOperationManifest>>;
+}>;
+export type AgentPluginSecretManifest = Readonly<{
+    env: string;
+    required: boolean;
+}>;
+export type AgentPluginSettingsManifest = Readonly<{
+    defaults: Readonly<Record<string, unknown>>;
+}>;
+export type AbotRuntimePluginExtension = Readonly<{
+    version: typeof ABOT_RUNTIME_EXTENSION_VERSION;
+    entrypoint: string;
+    catalogGroups?: readonly ToolCatalogGroup[];
+    settings?: AgentPluginSettingsManifest;
+    secrets?: Readonly<Record<string, AgentPluginSecretManifest>>;
+    capabilities: Readonly<Record<string, AgentPluginCapabilityManifest>>;
+}>;
+export type AgentPluginManifest = Readonly<{
+    $schema: typeof AGENT_PLUGIN_MANIFEST_SCHEMA;
+    name: string;
+    version?: string;
+    description?: string;
+    extensions: Readonly<{
+        [ABOT_RUNTIME_EXTENSION]: AbotRuntimePluginExtension;
+        [namespace: string]: unknown;
+    }>;
+}>;

package/dist/src/plugin-contract/manifest.js

@@ -0,0 +1,3 @@
+export const AGENT_PLUGIN_MANIFEST_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+export const ABOT_RUNTIME_EXTENSION = "ai.abot.runtime";
+export const ABOT_RUNTIME_EXTENSION_VERSION = 1;

package/dist/src/plugin-sdk/bounds.d.ts

@@ -0,0 +1,28 @@
+export type BoundedTextMetadata = Readonly<{
+    truncated: boolean;
+    originalChars: number;
+    returnedChars: number;
+    omittedChars: number;
+}>;
+export type BoundedText = Readonly<{
+    text: string;
+    metadata: BoundedTextMetadata;
+}>;
+export declare function boundText(value: string, options: Readonly<{
+    maxChars: number;
+    marker?: string;
+}>): BoundedText;
+export type BoundedCollectionMetadata = Readonly<{
+    truncated: boolean;
+    totalItems: number;
+    returnedItems: number;
+    omittedItems: number;
+}>;
+export type BoundedCollection<T> = Readonly<{
+    items: readonly T[];
+    metadata: BoundedCollectionMetadata;
+}>;
+export declare function boundCollection<T>(values: readonly T[], options: Readonly<{
+    maxItems: number;
+}>): BoundedCollection<T>;
+export declare function sanitizeJsonText(value: string): string;