graphlit-client 1.0.20260424002 → 1.0.20260424004

package/dist/client.d.ts

@@ -3130,6 +3130,7 @@ declare class Graphlit {
      * one for the same conversation, so messages are always processed in order.
      */
     private enqueueForConversation;
+    private resolveSpecificationReferences;
     /**
      * Execute an agent with streaming response
      * @param prompt - The user prompt

package/dist/client.js

@@ -164,6 +164,44 @@ function appendSystemMessages(messages, systemPrompt, additionalSystemInstructio
         });
     }
 }
+function toEntityReferenceInput(reference) {
+    return reference?.id ? { id: reference.id } : undefined;
+}
+function uniqueEntityReferences(references) {
+    const seen = new Set();
+    const unique = [];
+    for (const reference of references) {
+        if (!reference?.id || seen.has(reference.id)) {
+            continue;
+        }
+        seen.add(reference.id);
+        unique.push({ id: reference.id });
+    }
+    return unique;
+}
+function uniqueSpecifications(specifications) {
+    const seen = new Set();
+    const unique = [];
+    for (const specification of specifications) {
+        if (!specification?.id || seen.has(specification.id)) {
+            continue;
+        }
+        seen.add(specification.id);
+        unique.push(specification);
+    }
+    return unique;
+}
+function rebuildMessagesForSpecification(messages, specification, additionalSystemInstructions) {
+    const rebuilt = [];
+    let firstNonSystemIndex = 0;
+    while (firstNonSystemIndex < messages.length &&
+        messages[firstNonSystemIndex].role === Types.ConversationRoleTypes.System) {
+        firstNonSystemIndex++;
+    }
+    appendSystemMessages(rebuilt, specification.systemPrompt, additionalSystemInstructions);
+    rebuilt.push(...messages.slice(firstNonSystemIndex));
+    return rebuilt;
+}
 function computePersistedToolRoundDurationMs(toolCalls) {
     if (!toolCalls || toolCalls.length === 0) {
         return undefined;
@@ -5755,6 +5793,19 @@ class Graphlit {
         });
         return next;
     }
+    async resolveSpecificationReferences(references) {
+        const uniqueReferences = uniqueEntityReferences(references ?? []);
+        const specifications = [];
+        for (const reference of uniqueReferences) {
+            const response = await this.getSpecification(reference.id);
+            const specification = response.specification;
+            if (!specification) {
+                throw new Error(`Specification [${reference.id}] not found.`);
+            }
+            specifications.push(specification);
+        }
+        return specifications;
+    }
     /**
      * Execute an agent with streaming response
      * @param prompt - The user prompt
@@ -5784,14 +5835,28 @@ class Graphlit {
             throw new Error("Operation aborted");
         }
         try {
+            let actualConversationId = conversationId;
+            let existingConversation;
+            if (actualConversationId &&
+                specification?.id &&
+                !options?.fallbacks?.length) {
+                existingConversation = (await this.getConversation(actualConversationId))
+                    .conversation;
+            }
+            const effectiveSpecification = specification;
+            const conversationFallbacks = existingConversation?.fallbacks
+                ?.map((fallback) => toEntityReferenceInput(fallback))
+                .filter((fallback) => fallback != null) ?? [];
+            const fallbackReferences = uniqueEntityReferences(options?.fallbacks?.length ? options.fallbacks : conversationFallbacks);
             // Get full specification if needed
-            const fullSpec = specification?.id
-                ? (await this.getSpecification(specification.id))
+            const fullSpec = effectiveSpecification?.id
+                ? (await this.getSpecification(effectiveSpecification.id))
                     .specification
                 : undefined;
+            const fallbackSpecs = await this.resolveSpecificationReferences(fallbackReferences.filter((fallback) => fallback.id !== effectiveSpecification?.id));
             // Fail fast if a specification was requested but not found
-            if (specification?.id && !fullSpec) {
-                throw new Error(`Specification [${specification.id}] not found. Cannot fall back to promptAgent.`);
+            if (effectiveSpecification?.id && !fullSpec) {
+                throw new Error(`Specification [${effectiveSpecification.id}] not found. Cannot fall back to promptAgent.`);
             }
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING && fullSpec) {
                 console.log(`🔍 [streamAgent] Retrieved full specification:`, {
@@ -5805,11 +5870,13 @@ class Graphlit {
                 });
             }
             // Ensure conversation exists first (before streaming check)
-            let actualConversationId = conversationId;
             if (!actualConversationId) {
                 const createResponse = await this.createConversation({
                     name: `Streaming agent conversation`,
-                    specification: specification,
+                    specification: effectiveSpecification,
+                    ...(fallbackReferences.length > 0 && {
+                        fallbacks: fallbackReferences,
+                    }),
                     tools: tools,
                     filter: contentFilter,
                     augmentedFilter: augmentedFilter,
@@ -5832,13 +5899,16 @@ class Graphlit {
             await this.enqueueForConversation(actualConversationId, async () => {
                 // Check streaming support - fallback to promptAgent if not supported
                 // Also fall back when no specification is provided (can't route to provider locally)
-                if (!fullSpec || !this.supportsStreaming(fullSpec, tools)) {
+                const hasStreamingSpecification = !!fullSpec &&
+                    (this.supportsStreaming(fullSpec, tools) ||
+                        fallbackSpecs.some((fallbackSpec) => this.supportsStreaming(fallbackSpec, tools)));
+                if (!fullSpec || !hasStreamingSpecification) {
                     if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                         console.log(`\n⚠️ [streamAgent] ${!fullSpec ? "No specification provided" : "Streaming not supported"}, falling back to promptAgent with same conversation`);
                     }
                     // Fallback to promptAgent using the same conversation and parameters
                     const promptResult = await this.promptAgent(prompt, actualConversationId, // Preserve conversation
-                    specification, tools, toolHandlers, {
+                    effectiveSpecification, tools, toolHandlers, {
                         maxToolRounds: maxRounds,
                     }, mimeType, data, contentFilter, augmentedFilter, correlationId, persona);
                     // Convert promptAgent result to streaming events
@@ -5905,9 +5975,18 @@ class Graphlit {
                     return; // Exit early after successful fallback
                 }
                 // Create UI event adapter with model information
-                const modelName = fullSpec ? getModelName(fullSpec) : undefined;
-                const modelEnum = fullSpec ? getModelEnum(fullSpec) : undefined;
-                const serviceType = fullSpec ? getServiceType(fullSpec) : undefined;
+                const initialStreamingSpec = this.supportsStreaming(fullSpec, tools)
+                    ? fullSpec
+                    : fallbackSpecs.find((fallbackSpec) => this.supportsStreaming(fallbackSpec, tools)) || fullSpec;
+                const modelName = initialStreamingSpec
+                    ? getModelName(initialStreamingSpec)
+                    : undefined;
+                const modelEnum = initialStreamingSpec
+                    ? getModelEnum(initialStreamingSpec)
+                    : undefined;
+                const serviceType = initialStreamingSpec
+                    ? getServiceType(initialStreamingSpec)
+                    : undefined;
                 uiAdapter = new UIEventAdapter(onEvent, actualConversationId, {
                     smoothingEnabled: options?.smoothingEnabled ?? true,
                     chunkingStrategy: options?.chunkingStrategy ?? "word",
@@ -5918,7 +5997,7 @@ class Graphlit {
                 });
                 // Start the streaming conversation
                 // fullSpec is guaranteed non-null here — the !fullSpec check above returns early
-                await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona, options?.contextStrategy, options?.useResponsesApi, options?.instructions, options?.scratchpad, options?.skills, cacheableSystemInstructions);
+                await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona, options?.contextStrategy, options?.useResponsesApi, options?.instructions, options?.scratchpad, options?.skills, cacheableSystemInstructions, fallbackSpecs);
             }, abortSignal);
         }
         catch (error) {
@@ -5964,7 +6043,7 @@ class Graphlit {
     /**
      * Execute the streaming agent workflow with tool calling loop
      */
-    async executeStreamingAgent(prompt, conversationId, specification, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona, contextStrategy, useResponsesApi, instructions, scratchpad, skills, additionalSystemInstructions) {
+    async executeStreamingAgent(prompt, conversationId, specification, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona, contextStrategy, useResponsesApi, instructions, scratchpad, skills, additionalSystemInstructions, fallbackSpecifications) {
         // Collects artifact content IDs from tool handlers (e.g. code_execution).
         // Handlers register async ingestion promises; we await all of them before
         // completeConversation so the IDs are available without blocking the LLM.
@@ -6134,6 +6213,7 @@ class Graphlit {
             mimeType,
             data,
             additionalSystemInstructions,
+            fallbackSpecifications,
         });
         // Complete the conversation and get token count
         let finalTokens;
@@ -6190,8 +6270,19 @@ class Graphlit {
      * Shared between streamAgent (single turn) and runAgent (multi-turn harness).
      */
     async executeStreamingLoop(config) {
-        const { conversationId, specification, tools, toolHandlers, uiAdapter, budgetTracker, contextStrategy: { toolResultTokenLimit, toolRoundLimit, rebudgetThreshold, }, maxRounds, abortSignal, useResponsesApi, mimeType, data, correlationId, persona, additionalSystemInstructions, } = config;
+        const { conversationId, specification: initialSpecification, tools, toolHandlers, uiAdapter, budgetTracker, contextStrategy: { toolResultTokenLimit, toolRoundLimit, rebudgetThreshold, }, maxRounds, abortSignal, useResponsesApi, mimeType, data, correlationId, persona, additionalSystemInstructions, fallbackSpecifications, } = config;
         let messages = config.messages;
+        let specification = initialSpecification;
+        const streamingSpecifications = uniqueSpecifications([
+            initialSpecification,
+            ...(fallbackSpecifications ?? []),
+        ]);
+        let currentSpecificationIndex = 0;
+        let serviceType = getServiceType(specification);
+        let useOpenAIResponses = (useResponsesApi === true ||
+            (OPENAI_RESPONSES_AUTO_ROUTING_ENABLED && useResponsesApi !== false)) &&
+            serviceType === Types.ModelServiceTypes.OpenAi &&
+            isOpenAIResponsesEligibleModel(specification);
         let currentRound = 0;
         let fullMessage = "";
         let finalAssistantMessage = "";
@@ -6211,14 +6302,42 @@ class Graphlit {
                 return results.filter((r) => r != null);
             },
         };
-        const serviceType = getServiceType(specification);
-        const useOpenAIResponses = (useResponsesApi === true ||
-            (OPENAI_RESPONSES_AUTO_ROUTING_ENABLED && useResponsesApi !== false)) &&
-            serviceType === Types.ModelServiceTypes.OpenAi &&
-            isOpenAIResponsesEligibleModel(specification);
         let lastRoundReasoning;
         let openAIResponsesState;
         let openAIResponsesPendingToolMessages = [];
+        const selectNextStreamingSpecification = (reason) => {
+            for (let candidateIndex = currentSpecificationIndex + 1; candidateIndex < streamingSpecifications.length; candidateIndex++) {
+                const candidate = streamingSpecifications[candidateIndex];
+                if (!this.supportsStreaming(candidate, tools)) {
+                    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                        console.log(`\n⚠️ [Failover] Skipping fallback specification ${candidate.name} (${candidate.id}) because native streaming is not available`);
+                    }
+                    continue;
+                }
+                currentSpecificationIndex = candidateIndex;
+                specification = candidate;
+                serviceType = getServiceType(specification);
+                useOpenAIResponses =
+                    (useResponsesApi === true ||
+                        (OPENAI_RESPONSES_AUTO_ROUTING_ENABLED &&
+                            useResponsesApi !== false)) &&
+                        serviceType === Types.ModelServiceTypes.OpenAi &&
+                        isOpenAIResponsesEligibleModel(specification);
+                messages = rebuildMessagesForSpecification(messages, specification, additionalSystemInstructions);
+                openAIResponsesState = undefined;
+                openAIResponsesPendingToolMessages = [];
+                uiAdapter.setModelInfo({
+                    model: getModelEnum(specification),
+                    modelName: getModelName(specification),
+                    modelService: getServiceType(specification),
+                });
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n🔁 [Failover] Switching streaming provider after ${reason} | Spec: ${specification.name} (${specification.id}) | Service: ${serviceType}`);
+                }
+                return true;
+            }
+            return false;
+        };
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING && budgetTracker) {
             console.log(`📊 [Context Management] Initialized budget tracker: ${budgetTracker.usagePercent}% used, ` +
                 `${budgetTracker.remaining.toLocaleString()} tokens remaining. ` +
@@ -6542,9 +6661,15 @@ class Graphlit {
                         }
                     }
                     else {
+                        const unsupportedServiceType = serviceType;
+                        if (selectNextStreamingSpecification(`no native streaming available for ${unsupportedServiceType}`)) {
+                            uiAdapter.resetForRetry(preRoundMessage);
+                            providerAttempt = -1;
+                            continue;
+                        }
                         // Fallback to non-streaming
                         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                            console.log(`\n⚠️  [Fallback] No native streaming available for ${serviceType} (Round ${currentRound})`);
+                            console.log(`\n⚠️  [Fallback] No native streaming available for ${unsupportedServiceType} (Round ${currentRound})`);
                             console.log(`   Falling back to non-streaming promptConversation`);
                             console.log(`   This should NOT happen if clients are properly set!`);
                         }
@@ -6561,6 +6686,13 @@ class Graphlit {
                     if (abortSignal?.aborted)
                         throw retryError;
                     const isRetryable = retryError instanceof ProviderError && retryError.retryable;
+                    if (isRetryable &&
+                        providerAttempt >= DEFAULT_PROVIDER_RETRIES &&
+                        selectNextStreamingSpecification(`${retryError.provider} retry exhaustion: ${retryError.message}`)) {
+                        uiAdapter.resetForRetry(preRoundMessage);
+                        providerAttempt = -1;
+                        continue;
+                    }
                     if (!isRetryable || providerAttempt >= DEFAULT_PROVIDER_RETRIES) {
                         throw retryError;
                     }
@@ -6999,6 +7131,7 @@ class Graphlit {
             reasoning: lastRoundReasoning,
             intermediateMessages: messageInputs,
             lastRoundReasoning,
+            usedSpecification: specification,
         };
     }
     // ────────────────────────────────────────────────────────────────────────────
@@ -7127,6 +7260,8 @@ class Graphlit {
                 ? (await this.getSpecification(agentSpec.id))
                     .specification
                 : undefined;
+            let activeFullSpec = fullSpec;
+            let fallbackReferences = [];
             // Initialize evaluator and stuck detector
             const evaluator = new TurnEvaluator({
                 maxTurns,
@@ -7192,7 +7327,6 @@ class Graphlit {
                     filter: agentFilter,
                     persona: options?.persona,
                     augmentedFilter: options?.augmentedFilter,
-                    fallbacks: options?.fallbacks,
                 }, options?.correlationId);
                 conversationId = createResponse.createConversation?.id ?? "";
                 if (!conversationId) {
@@ -7203,6 +7337,9 @@ class Graphlit {
                 // Resume: reconstruct TurnResults from conversation history so the
                 // stuck detector has full context from prior turns.
                 const convResponse = await this.getConversation(conversationId);
+                fallbackReferences = uniqueEntityReferences(convResponse.conversation?.fallbacks
+                    ?.map((fallback) => toEntityReferenceInput(fallback))
+                    .filter((fallback) => fallback != null) ?? []);
                 const existingMessages = convResponse.conversation?.messages;
                 if (existingMessages && existingMessages.length > 0) {
                     const resumedTurns = this.reconstructTurnResults(existingMessages);
@@ -7214,6 +7351,7 @@ class Graphlit {
                     }
                 }
             }
+            const fallbackSpecs = await this.resolveSpecificationReferences(fallbackReferences.filter((fallback) => fallback.id !== fullSpec?.id));
             // ── Phase 2: The Loop ──────────────────────────────────────────────
             let pendingStuckIntervention;
             let currentPrompt = prompt;
@@ -7279,7 +7417,7 @@ class Graphlit {
                     // Bare fast-path: skip formatConversation, reuse cached token limits
                     // Build message from last turn's context
                     // The messages array is rebuilt from the conversation state
-                    const bareMessages = this.buildBareMessages(fullSpec, turnResults, currentPrompt, options?.additionalSystemInstructions);
+                    const bareMessages = this.buildBareMessages(activeFullSpec, turnResults, currentPrompt, options?.additionalSystemInstructions);
                     loopMessages = bareMessages;
                     // Estimate tokens from the messages
                     const usedTokens = loopMessages.reduce((sum, msg) => sum + estimateTokens(msg.message || ""), 0);
@@ -7287,7 +7425,7 @@ class Graphlit {
                 }
                 else {
                     // Formatted path: call formatConversation
-                    const formatResponse = await this.formatConversation(turn === 0 ? prompt : "Continue.", conversationId, agentSpec, allTools, undefined, true, options?.correlationId, options?.persona, mergedInstructions, agentScratchpad, options?.skills);
+                    const formatResponse = await this.formatConversation(turn === 0 ? prompt : "Continue.", conversationId, activeFullSpec ? { id: activeFullSpec.id } : agentSpec, allTools, undefined, true, options?.correlationId, options?.persona, mergedInstructions, agentScratchpad, options?.skills);
                     const formattedMessage = formatResponse.formatConversation?.message;
                     const conversationHistory = formatResponse.formatConversation?.details?.messages;
                     const formatDetails = formatResponse.formatConversation?.details;
@@ -7302,7 +7440,7 @@ class Graphlit {
                     }
                     // Build messages from format response
                     loopMessages = [];
-                    appendSystemMessages(loopMessages, fullSpec?.systemPrompt, options?.additionalSystemInstructions);
+                    appendSystemMessages(loopMessages, activeFullSpec?.systemPrompt, options?.additionalSystemInstructions);
                     if (conversationHistory && conversationHistory.length > 0) {
                         for (const historyMessage of conversationHistory) {
                             if (historyMessage) {
@@ -7361,9 +7499,15 @@ class Graphlit {
                     }
                 }
                 // 6. Create UI adapter for this turn
-                const modelName = fullSpec ? getModelName(fullSpec) : undefined;
-                const modelEnum = fullSpec ? getModelEnum(fullSpec) : undefined;
-                const serviceType = fullSpec ? getServiceType(fullSpec) : undefined;
+                const modelName = activeFullSpec
+                    ? getModelName(activeFullSpec)
+                    : undefined;
+                const modelEnum = activeFullSpec
+                    ? getModelEnum(activeFullSpec)
+                    : undefined;
+                const serviceType = activeFullSpec
+                    ? getServiceType(activeFullSpec)
+                    : undefined;
                 const uiAdapter = new UIEventAdapter((event) => {
                     wrappedOnEvent(event);
                     options?.onStreamEvent?.(event);
@@ -7382,7 +7526,7 @@ class Graphlit {
                 });
                 // Resolve context strategy
                 const callerStrategy = options?.contextStrategy ?? {};
-                const serverStrategy = fullSpec?.strategy;
+                const serverStrategy = activeFullSpec?.strategy;
                 const mergedStrategy = {
                     toolResultTokenLimit: callerStrategy.toolResultTokenLimit ??
                         serverStrategy?.toolResultTokenLimit ??
@@ -7400,7 +7544,7 @@ class Graphlit {
                 try {
                     loopResult = await this.executeStreamingLoop({
                         conversationId,
-                        specification: fullSpec,
+                        specification: activeFullSpec,
                         messages: loopMessages,
                         tools: allTools,
                         toolHandlers: allToolHandlers,
@@ -7413,11 +7557,15 @@ class Graphlit {
                         correlationId: options?.correlationId,
                         persona: options?.persona,
                         additionalSystemInstructions: options?.additionalSystemInstructions,
+                        fallbackSpecifications: fallbackSpecs,
                     });
                 }
                 finally {
                     uiAdapter.dispose();
                 }
+                if (loopResult.usedSpecification) {
+                    activeFullSpec = loopResult.usedSpecification;
+                }
                 // 8. Detect task_complete before persistence. The streaming loop
                 // records the terminal assistant/tool-call round, but does not execute
                 // the completion handler or start a follow-up filler round.

package/dist/generated/graphql-documents.js

@@ -10379,6 +10379,38 @@ export const GetFeed = gql `
       }
       readLimit
     }
+    skill {
+      type
+      isRecursive
+      allowedPaths
+      excludedPaths
+      github {
+        authenticationType
+        uri
+        repositoryOwner
+        repositoryName
+        clientId
+        clientSecret
+        refreshToken
+        personalAccessToken
+        connector {
+          id
+        }
+      }
+      gitlab {
+        authenticationType
+        projectPath
+        branch
+        clientId
+        clientSecret
+        refreshToken
+        personalAccessToken
+        connector {
+          id
+        }
+      }
+      readLimit
+    }
     email {
       type
       includeAttachments
@@ -11482,6 +11514,38 @@ export const QueryFeeds = gql `
         }
         readLimit
       }
+      skill {
+        type
+        isRecursive
+        allowedPaths
+        excludedPaths
+        github {
+          authenticationType
+          uri
+          repositoryOwner
+          repositoryName
+          clientId
+          clientSecret
+          refreshToken
+          personalAccessToken
+          connector {
+            id
+          }
+        }
+        gitlab {
+          authenticationType
+          projectPath
+          branch
+          clientId
+          clientSecret
+          refreshToken
+          personalAccessToken
+          connector {
+            id
+          }
+        }
+        readLimit
+      }
       email {
         type
         includeAttachments
@@ -19157,6 +19221,10 @@ export const GetSkill = gql `
     correlationId
     text
     skillOwner
+    feed {
+      id
+      name
+    }
     arguments {
       name
       description
@@ -19187,6 +19255,10 @@ export const QuerySkills = gql `
       correlationId
       text
       skillOwner
+      feed {
+        id
+        name
+      }
       arguments {
         name
         description

package/dist/generated/graphql-types.d.ts

@@ -3373,6 +3373,8 @@ export type ConnectorUpdateInput = {
     integration?: InputMaybe<IntegrationConnectorInput>;
     /** The name of the connector. */
     name?: InputMaybe<Scalars['String']['input']>;
+    /** The connector type. */
+    type?: InputMaybe<ConnectorTypes>;
 };
 /** Represents content. */
 export type Content = {
@@ -7905,6 +7907,8 @@ export type Feed = {
     search?: Maybe<SearchFeedProperties>;
     /** The site feed properties. */
     site?: Maybe<SiteFeedProperties>;
+    /** The skill feed properties. */
+    skill?: Maybe<SkillFeedProperties>;
     /** The Slack feed properties. */
     slack?: Maybe<SlackFeedProperties>;
     /** The state of the feed (i.e. created, finished). */
@@ -8095,6 +8099,8 @@ export type FeedInput = {
     search?: InputMaybe<SearchFeedPropertiesInput>;
     /** The site feed properties. */
     site?: InputMaybe<SiteFeedPropertiesInput>;
+    /** The skill feed properties. */
+    skill?: InputMaybe<SkillFeedPropertiesInput>;
     /** The Slack feed properties. */
     slack?: InputMaybe<SlackFeedPropertiesInput>;
     /** The feed sync mode. */
@@ -8177,6 +8183,8 @@ export type FeedPreviewInput = {
     search?: InputMaybe<SearchFeedPropertiesInput>;
     /** The site feed properties. */
     site?: InputMaybe<SiteFeedPropertiesInput>;
+    /** The skill feed properties. */
+    skill?: InputMaybe<SkillFeedPropertiesInput>;
     /** The Slack feed properties. */
     slack?: InputMaybe<SlackFeedPropertiesInput>;
     /** The Twitter feed properties. */
@@ -8205,6 +8213,10 @@ export type FeedPreviewResult = {
     itemCount: Scalars['Long']['output'];
     /** The observable type histogram. */
     observableTypeSummary?: Maybe<Array<ObservableTypeSummary>>;
+    /** The skill feed preview summary. */
+    skillSummary?: Maybe<SkillFeedPreviewSummary>;
+    /** The skill feed preview items. */
+    skills?: Maybe<Array<SkillFeedPreviewItem>>;
     /** Any warnings generated during the preview scan. */
     warnings?: Maybe<Array<Scalars['String']['output']>>;
 };
@@ -8429,6 +8441,8 @@ export declare enum FeedTypes {
     Search = "SEARCH",
     /** Cloud storage site feed */
     Site = "SITE",
+    /** Skill package feed */
+    Skill = "SKILL",
     /** Slack channel feed */
     Slack = "SLACK",
     /** Twitter/X feed */
@@ -8506,6 +8520,8 @@ export type FeedUpdateInput = {
     search?: InputMaybe<SearchFeedPropertiesUpdateInput>;
     /** The site feed properties. */
     site?: InputMaybe<SiteFeedPropertiesUpdateInput>;
+    /** The skill feed properties. */
+    skill?: InputMaybe<SkillFeedPropertiesUpdateInput>;
     /** The Slack feed properties. */
     slack?: InputMaybe<SlackFeedPropertiesUpdateInput>;
     /** The feed sync mode. */
@@ -24280,6 +24296,8 @@ export type Skill = {
     creationDate: Scalars['DateTime']['output'];
     /** The description of the skill. */
     description?: Maybe<Scalars['String']['output']>;
+    /** The feed that installed this skill. */
+    feed?: Maybe<Feed>;
     /** The ID of the skill. */
     id: Scalars['ID']['output'];
     /** The skill external identifier. */
@@ -24320,6 +24338,107 @@ export type SkillArgumentInput = {
     /** Whether this argument is required. Defaults to true. */
     required?: InputMaybe<Scalars['Boolean']['input']>;
 };
+/** Represents a skill feed preview item. */
+export type SkillFeedPreviewItem = {
+    __typename?: 'SkillFeedPreviewItem';
+    /** The current skill hash. */
+    currentHash?: Maybe<Scalars['String']['output']>;
+    /** The skill description. */
+    description?: Maybe<Scalars['String']['output']>;
+    /** The skill file identifier. */
+    fileIdentifier: Scalars['String']['output'];
+    /** The skill name. */
+    name?: Maybe<Scalars['String']['output']>;
+    /** The preview operation. */
+    operation: SkillFeedPreviewOperations;
+    /** The skill file path. */
+    path: Scalars['String']['output'];
+    /** The number of inlined markdown references. */
+    referenceCount?: Maybe<Scalars['Long']['output']>;
+    /** The inlined markdown references. */
+    references?: Maybe<Array<Scalars['String']['output']>>;
+    /** The upstream skill hash. */
+    upstreamHash?: Maybe<Scalars['String']['output']>;
+    /** Warnings generated for this skill. */
+    warnings?: Maybe<Array<Scalars['String']['output']>>;
+};
+/** Skill feed preview operation */
+export declare enum SkillFeedPreviewOperations {
+    /** Invalid skill */
+    Invalid = "INVALID",
+    /** New skill */
+    New = "NEW",
+    /** Unchanged skill */
+    Unchanged = "UNCHANGED",
+    /** Updated skill */
+    Update = "UPDATE"
+}
+/** Represents a skill feed preview summary. */
+export type SkillFeedPreviewSummary = {
+    __typename?: 'SkillFeedPreviewSummary';
+    /** The total number of skills found. */
+    foundCount: Scalars['Long']['output'];
+    /** The number of invalid skills. */
+    invalidCount: Scalars['Long']['output'];
+    /** The number of new skills. */
+    newCount: Scalars['Long']['output'];
+    /** The number of unchanged skills. */
+    unchangedCount: Scalars['Long']['output'];
+    /** The number of updated skills. */
+    updateCount: Scalars['Long']['output'];
+};
+/** Represents skill feed properties. */
+export type SkillFeedProperties = {
+    __typename?: 'SkillFeedProperties';
+    /** The list of regular expressions for URL paths to be crawled, i.e. "^/public/blogs/.*". */
+    allowedPaths?: Maybe<Array<Scalars['String']['output']>>;
+    /** Feed connector type. */
+    connectorType: FeedConnectorTypes;
+    /** The list of regular expressions for URL paths to not be crawled, i.e. "^/internal/private/.*". */
+    excludedPaths?: Maybe<Array<Scalars['String']['output']>>;
+    /** GitHub properties. */
+    github?: Maybe<GitHubFeedProperties>;
+    /** GitLab properties. */
+    gitlab?: Maybe<GitLabFeedProperties>;
+    /** Should the feed enumerate files recursively via folders. */
+    isRecursive?: Maybe<Scalars['Boolean']['output']>;
+    /** The limit of items to be read from feed, defaults to 100. */
+    readLimit?: Maybe<Scalars['Int']['output']>;
+    /** Feed service type. */
+    type: FeedServiceTypes;
+};
+/** Represents skill feed properties. */
+export type SkillFeedPropertiesInput = {
+    /** The list of regular expressions for URL paths to be crawled, i.e. "^/public/blogs/.*". */
+    allowedPaths?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** The list of regular expressions for URL paths to not be crawled, i.e. "^/internal/private/.*". */
+    excludedPaths?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** GitHub properties. */
+    github?: InputMaybe<GitHubFeedPropertiesInput>;
+    /** GitLab properties. */
+    gitlab?: InputMaybe<GitLabFeedPropertiesInput>;
+    /** Should the feed enumerate files recursively via folders. */
+    isRecursive?: InputMaybe<Scalars['Boolean']['input']>;
+    /** The limit of items to be read from feed, defaults to 100. */
+    readLimit?: InputMaybe<Scalars['Int']['input']>;
+    /** Feed service type. */
+    type: FeedServiceTypes;
+};
+/** Represents skill feed properties. */
+export type SkillFeedPropertiesUpdateInput = {
+    /** The list of regular expressions for URL paths to be crawled, i.e. "^/public/blogs/.*". */
+    allowedPaths?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** The list of regular expressions for URL paths to not be crawled, i.e. "^/internal/private/.*". */
+    excludedPaths?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** GitHub properties. */
+    github?: InputMaybe<GitHubFeedPropertiesUpdateInput>;
+    /** GitLab properties. */
+    gitlab?: InputMaybe<GitLabFeedPropertiesUpdateInput>;
+    /** Should the feed enumerate files recursively via folders. */
+    isRecursive?: InputMaybe<Scalars['Boolean']['input']>;
+    /** The limit of items to be read from feed, defaults to 100. */
+    readLimit?: InputMaybe<Scalars['Int']['input']>;
+};
 /** Represents a filter for skills. */
 export type SkillFilter = {
     /** Filter by collections. */
@@ -24330,8 +24449,12 @@ export type SkillFilter = {
     creationDateRange?: InputMaybe<DateRangeFilter>;
     /** The sort direction for query results. */
     direction?: InputMaybe<OrderDirectionTypes>;
+    /** Filter by feeds. */
+    feeds?: InputMaybe<Array<EntityReferenceFilter>>;
     /** Filter by whether the skill belongs to any collections. */
     hasCollections?: InputMaybe<Scalars['Boolean']['input']>;
+    /** Filter by whether the skill is associated with any feeds. */
+    hasFeeds?: InputMaybe<Scalars['Boolean']['input']>;
     /** Filter skill(s) by their unique ID. */
     id?: InputMaybe<Scalars['ID']['input']>;
     /** Filter by external identifier. */
@@ -24365,6 +24488,8 @@ export type SkillInput = {
     collections?: InputMaybe<Array<EntityReferenceInput>>;
     /** The description of the skill. */
     description?: InputMaybe<Scalars['String']['input']>;
+    /** The feed that installed this skill. */
+    feed?: InputMaybe<EntityReferenceInput>;
     /** The skill external identifier. */
     identifier?: InputMaybe<Scalars['String']['input']>;
     /** The name of the skill. */
@@ -38780,6 +38905,43 @@ export type GetFeedQuery = {
                 } | null;
             } | null;
         } | null;
+        skill?: {
+            __typename?: 'SkillFeedProperties';
+            type: FeedServiceTypes;
+            isRecursive?: boolean | null;
+            allowedPaths?: Array<string> | null;
+            excludedPaths?: Array<string> | null;
+            readLimit?: number | null;
+            github?: {
+                __typename?: 'GitHubFeedProperties';
+                authenticationType?: GitHubAuthenticationTypes | null;
+                uri?: any | null;
+                repositoryOwner: string;
+                repositoryName: string;
+                clientId?: string | null;
+                clientSecret?: string | null;
+                refreshToken?: string | null;
+                personalAccessToken?: string | null;
+                connector?: {
+                    __typename?: 'EntityReference';
+                    id: string;
+                } | null;
+            } | null;
+            gitlab?: {
+                __typename?: 'GitLabFeedProperties';
+                authenticationType?: GitLabAuthenticationTypes | null;
+                projectPath: string;
+                branch?: string | null;
+                clientId?: string | null;
+                clientSecret?: string | null;
+                refreshToken?: string | null;
+                personalAccessToken?: string | null;
+                connector?: {
+                    __typename?: 'EntityReference';
+                    id: string;
+                } | null;
+            } | null;
+        } | null;
         email?: {
             __typename?: 'EmailFeedProperties';
             type: FeedServiceTypes;
@@ -40099,6 +40261,43 @@ export type QueryFeedsQuery = {
                     } | null;
                 } | null;
             } | null;
+            skill?: {
+                __typename?: 'SkillFeedProperties';
+                type: FeedServiceTypes;
+                isRecursive?: boolean | null;
+                allowedPaths?: Array<string> | null;
+                excludedPaths?: Array<string> | null;
+                readLimit?: number | null;
+                github?: {
+                    __typename?: 'GitHubFeedProperties';
+                    authenticationType?: GitHubAuthenticationTypes | null;
+                    uri?: any | null;
+                    repositoryOwner: string;
+                    repositoryName: string;
+                    clientId?: string | null;
+                    clientSecret?: string | null;
+                    refreshToken?: string | null;
+                    personalAccessToken?: string | null;
+                    connector?: {
+                        __typename?: 'EntityReference';
+                        id: string;
+                    } | null;
+                } | null;
+                gitlab?: {
+                    __typename?: 'GitLabFeedProperties';
+                    authenticationType?: GitLabAuthenticationTypes | null;
+                    projectPath: string;
+                    branch?: string | null;
+                    clientId?: string | null;
+                    clientSecret?: string | null;
+                    refreshToken?: string | null;
+                    personalAccessToken?: string | null;
+                    connector?: {
+                        __typename?: 'EntityReference';
+                        id: string;
+                    } | null;
+                } | null;
+            } | null;
             email?: {
                 __typename?: 'EmailFeedProperties';
                 type: FeedServiceTypes;
@@ -49437,6 +49636,11 @@ export type GetSkillQuery = {
             __typename?: 'EntityReference';
             id: string;
         } | null;
+        feed?: {
+            __typename?: 'Feed';
+            id: string;
+            name: string;
+        } | null;
         arguments?: Array<{
             __typename?: 'SkillArgument';
             name: string;
@@ -49475,6 +49679,11 @@ export type QuerySkillsQuery = {
                 __typename?: 'Owner';
                 id: string;
             };
+            feed?: {
+                __typename?: 'Feed';
+                id: string;
+                name: string;
+            } | null;
             arguments?: Array<{
                 __typename?: 'SkillArgument';
                 name: string;

package/dist/generated/graphql-types.js

@@ -1594,6 +1594,8 @@ export var FeedTypes;
     FeedTypes["Search"] = "SEARCH";
     /** Cloud storage site feed */
     FeedTypes["Site"] = "SITE";
+    /** Skill package feed */
+    FeedTypes["Skill"] = "SKILL";
     /** Slack channel feed */
     FeedTypes["Slack"] = "SLACK";
     /** Twitter/X feed */
@@ -3225,6 +3227,18 @@ export var SiteTypes;
     /** Watch cloud storage site */
     SiteTypes["Watch"] = "WATCH";
 })(SiteTypes || (SiteTypes = {}));
+/** Skill feed preview operation */
+export var SkillFeedPreviewOperations;
+(function (SkillFeedPreviewOperations) {
+    /** Invalid skill */
+    SkillFeedPreviewOperations["Invalid"] = "INVALID";
+    /** New skill */
+    SkillFeedPreviewOperations["New"] = "NEW";
+    /** Unchanged skill */
+    SkillFeedPreviewOperations["Unchanged"] = "UNCHANGED";
+    /** Updated skill */
+    SkillFeedPreviewOperations["Update"] = "UPDATE";
+})(SkillFeedPreviewOperations || (SkillFeedPreviewOperations = {}));
 export var SlackAuthenticationTypes;
 (function (SlackAuthenticationTypes) {
     SlackAuthenticationTypes["Connector"] = "CONNECTOR";

package/dist/streaming/ui-event-adapter.d.ts

@@ -48,6 +48,11 @@ export declare class UIEventAdapter {
         modelName?: string;
         modelService?: string;
     });
+    setModelInfo(options: {
+        model?: string;
+        modelName?: string;
+        modelService?: string;
+    }): void;
     /**
      * Process a raw streaming event and emit appropriate UI events
      */

package/dist/streaming/ui-event-adapter.js

@@ -64,6 +64,11 @@ export class UIEventAdapter {
             this.reasoningBuffer = new ChunkBuffer("sentence");
         }
     }
+    setModelInfo(options) {
+        this.model = options.model;
+        this.modelName = options.modelName;
+        this.modelService = options.modelService;
+    }
     /**
      * Process a raw streaming event and emit appropriate UI events
      */

package/dist/types/agent.d.ts

@@ -76,6 +76,8 @@ export interface StreamAgentOptions {
     skills?: EntityReferenceInput[];
     /** Stable, caller-supplied system-channel content to append after the specification system prompt. */
     additionalSystemInstructions?: string;
+    /** Ordered fallback specifications to try for native streaming after retryable provider failures. */
+    fallbacks?: EntityReferenceInput[];
 }
 export interface ToolCallResult {
     id: string;
@@ -152,7 +154,6 @@ export interface RunAgentOptions {
     toolHandlers?: Record<string, ToolHandler>;
     persona?: EntityReferenceInput;
     augmentedFilter?: ContentCriteriaInput;
-    fallbacks?: EntityReferenceInput[];
     maxTurns?: number;
     maxWallClockMs?: number;
     maxToolCalls?: number;
@@ -225,6 +226,7 @@ export interface StreamingLoopConfig {
     mimeType?: string;
     data?: string;
     additionalSystemInstructions?: string;
+    fallbackSpecifications?: Specification[];
 }
 /** Result returned from executeStreamingLoop. */
 export interface StreamingLoopResult {
@@ -238,4 +240,5 @@ export interface StreamingLoopResult {
     reasoning?: ReasoningMetadata;
     intermediateMessages: ConversationMessageInput[];
     lastRoundReasoning?: ReasoningMetadata;
+    usedSpecification?: Specification;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20260424002",
+  "version": "1.0.20260424004",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",