Láimhseáil earráidí agus cúltacaí
Ar an leathanach seo
Láimhseáil earráidí agus cúltacaí
Tugann glao feidhme dúshlán nach mbíonn ag cód clasaiceach: nuair a theipeann ar d’fheidhm, tá dhá ghlacadóir leis an earráid sin. Do iarratas, mar is gnách—agus an tsamhail, atá ag fanacht le toradh chun leanúint ar aghaidh. Má dhéanann tú dearmad den rud seo, cruthaíonn tú an comhartha is mearbhaillí sa táirgeadh: comhrá a stopann go tobann gan aon mhíniú, toisc go ndearnadh eisceacht a shlogadh ar thaobh an fhreastalaí agus tá an tsamhail fós ag fanacht.
Is é an riail a struchtúraíonn an ceacht seo ar fad ná: tabair function_call_output ar ais i gcónaí, fiú amháin ar theip. Is féidir le samhail a chuirtear ar an eolas nach bhfuil API ar fáil rogha eile a mholadh, soiléiriú a iarraidh, nó an scéal a mhíniú don úsáideoir. Ní féidir le samhail nach bhfaigheann aon rud aon rud a dhéanamh.
Earráidí a thabhairt ar ais don tsamhail
Tá an formáid na hearráide chomh tábhachtach céanna leis an earráid a sheoladh. Ní mhúineann “Earráid” lom aon rud don tsamhail; ceadóidh oibiacht JSON a dhéanann idirdhealú ar chineál na hearráide, cibé acu atá sí sealadach nó buan, agus na chéad chéimeanna eile, don tsamhail cinneadh a dhéanamh. Tá sé seo contrártha don chiall: tá tú ag scríobh teachtaireachtaí earráide atá le léamh ag meaisín réasúnaíochta, ní le logáil do dhaoine.
import json
from openai import OpenAI
client = OpenAI()
def execute_function(name: str, arguments: str, call_id: str) -> dict:
try:
args = json.loads(arguments)
result = dispatcher[name](**args)
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps(result)
}
except KeyError:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": "unknown_function",
"message": f"The function '{name}' does not exist"
})
}
except json.JSONDecodeError:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": "invalid_arguments",
"message": "The JSON arguments are malformed"
})
}
except Exception as e:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": "internal_error",
"message": str(e)
})
}
Atriail le cúltaca easpónantúil
Ní bhíonn ciall ag baint le hiarracht athdhéanta ach amháin i gcás fadhbanna a d’fhéadfadh réiteach ar an dara hiarracht: gearradh líonra, cóid stádais 429, nó easnamh sealadacha. Má dhéanann tú iarracht ar iarratas a diúltaíodh mar gheall ar fhíordheimhniú neamhbhailí nó paraiméadair míchearta, ní dhéanfaidh tú ach moill a chur ar an teip agus líon na nglao a iolrú. Sin é an fáth go scagann an cód thíos earráidí go sonrach—déanann an scagadh an obair, agus ní mórán ach an chirt atá tú i bhfiacha don seirbhís i gcéin an cúltaca.
import time
import random
def execute_with_retry(func, args, max_retries=3, base_delay=1.0):
"""Retry with exponential backoff and jitter."""
for attempt in range(max_retries + 1):
try:
return func(**args)
except (ConnectionError, TimeoutError) as e:
if attempt == max_retries:
raise
delay = base_delay * (2 ** attempt) + random.uniform(0, 0.5)
time.sleep(delay)
except ValueError:
# Data error: do not retry
raise
def execute_function_robust(name, arguments, call_id):
args = json.loads(arguments)
try:
result = execute_with_retry(dispatcher[name], args)
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps(result)
}
except Exception as e:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": type(e).__name__,
"message": str(e),
"retries_performed": 3
})
}
Teorainneacha ama in aghaidh na feidhme
Tá teorainn ama amháin do gach feidhm míchumraithe i gcónaí: ró-ghearr, agus maraíonn sí próiseáil throm; ró-fhada, agus fanann an t-úsáideoir ar chuardach simplí taisce. Bunaithe gach luach ar fhad ama breathnaithe faoi ghnáthchoinníollacha, le corrlach—ní ar an gcás is measa is féidir a shamhlú, rud a chiallódh go héifeachtach gan aon teorainn ama a bheith agat ar chor ar bith.
import signal
from functools import wraps
TIMEOUTS = {
"search_client": 5,
"generate_report": 30,
"send_email": 10,
}
def with_timeout(func, timeout_seconds):
"""Executes a function with a timeout."""
import concurrent.futures
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(func)
try:
return future.result(timeout=timeout_seconds)
except concurrent.futures.TimeoutError:
raise TimeoutError(
f"Function interrupted after {timeout_seconds}s"
)
def execute_with_timeout(name, arguments, call_id):
args = json.loads(arguments)
timeout = TIMEOUTS.get(name, 10) # 10s by default
try:
result = with_timeout(
lambda: dispatcher[name](**args),
timeout
)
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps(result)
}
except TimeoutError as e:
return {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps({
"error": "timeout",
"message": str(e),
"suggestion": "Retry with more specific criteria"
})
}
Cúltaca idir feidhmeanna
Is comhréiteach é an cúltaca, ní freagairt instinctúil: tá sonraí taisce atá sé huaire an chloig d’aois níos fearr ná gan aon rud do dheais, agus i bhfad níos measa ná gan aon rud d’iarmhéid bainc. Nuair a dhéanann tú díghrádú, abair é—sa toradh a thugtar ar ais don tsamhail, ionas gur féidir léi rabhadh a thabhairt don úsáideoir seachas sonraí seanbhunaithe a chur i láthair mar shonraí úra.
async def search_product(term: str) -> dict:
"""Search with fallback: primary API -> cache -> local database."""
# Attempt 1: Catalog API
try:
return await api_catalog.search(term)
except Exception:
pass
# Attempt 2: Redis cache
try:
cached = await redis_client.get(f"product:{term}")
if cached:
result = json.loads(cached)
result["_source"] = "cache"
result["_warning"] = "Data may be outdated"
return result
except Exception:
pass
# Attempt 3: Local SQLite database
try:
row = db.execute(
"SELECT * FROM products WHERE name LIKE ?",
(f"%{term}%",)
).fetchone()
if row:
return {
"name": row["name"],
"price": row["price"],
"_source": "local_db",
"_warning": "Data from last synchronization"
}
except Exception:
pass
return {
"error": "unavailable",
"message": "No data source accessible for this search"
}
Briseadh ciorcaid
Déileálann an briseadh ciorcaid leis an rud nach féidir le hiarracht athdhéanta a dhéanamh: seirbhís atá síos ar feadh tréimhse fada. Tar éis N teip, tripeálann sé agus filleann sé earráid láithreach, gan iarracht a dhéanamh fiú, ansin ligeann sé d’iarratas tástála tríd ó am go chéile chun seiceáil an bhfuil téarnamh ann. Tá an gnóthachan dúbailte—stopann do chuid úsáideoirí ag fanacht ar theorainn ama ar gach iarratas, agus ní choinnítear an tseirbhís atá ag streachailt síos ag do chuid iarrachtaí athdhéanta.
from datetime import datetime, timedelta
class CircuitBreaker:
def __init__(self, failure_threshold=5, open_duration=60):
self.threshold = failure_threshold
self.duration = open_duration
self.failures = 0
self.last_failure = None
self.state = "closed" # closed, open, half-open
def can_execute(self) -> bool:
if self.state == "closed":
return True
if self.state == "open":
if datetime.now() - self.last_failure > timedelta(seconds=self.duration):
self.state = "half-open"
return True
return False
return True # half-open: allow one test attempt
def record_success(self):
self.failures = 0
self.state = "closed"
def record_failure(self):
self.failures += 1
self.last_failure = datetime.now()
if self.failures >= self.threshold:
self.state = "open"
# One circuit breaker per external service
breakers = {
"weather_api": CircuitBreaker(failure_threshold=3, open_duration=30),
"catalog_api": CircuitBreaker(failure_threshold=5, open_duration=60),
}
Lúb láidir iomlán
Tugann an patrún iomlán na cúig mheicníocht thuas le chéile. Déanann aon réamhchúram amháin sábháilte go hiomlán é, agus is furasta dearmad a dhéanamh air: cuir teorainn le líon na n-athrá. Is annamh a dhéanann samhail lúbadh ag glaoch ar fheidhm nach maith léi an toradh atá uirthi, ach gan uasteorainn, dófaidh sí do bhuiséad go dtí go mbeidh tú tuirseach—agus is é sin an cineál teagmhais a fhionnann tú ar an mbille.
def robust_loop(prompt, tools, max_turns=10):
messages = prompt
for turn in range(max_turns):
response = client.responses.create(
model="gpt-5.6-terra",
input=messages,
tools=tools
)
calls = [i for i in response.output if i.type == "function_call"]
if not calls:
return response.output_text
results = []
for call in calls:
result = execute_function_robust(
call.name, call.arguments, call.call_id
)
results.append(result)
messages = response.output + results
return "Workflow interrupted: turn limit reached"
Príomhphointí
- Tabair
function_call_outputar ais i gcónaí, fiú amháin ar earráid - Struchtúraigh earráidí mar JSON ionas gur féidir leis an tsamhail iad a úsáid
- Déan iarracht athdhéanta ar earráidí sealadacha amháin le cúltaca easpónantúil
- Cuir cúltacaí i bhfeidhm idir foinsí sonraí
- Úsáid briseadh ciorcaid chun seirbhísí atá ag teip a chosaint